agentic-qe 3.11.3 → 3.11.5

package/dist/learning/local-judge-client.js

@@ -17,6 +17,7 @@
  *   qwen3:30b-a3b   — 18GB, highest quality, use only if RAM permits
  */
 import { LoggerFactory } from '../logging/index.js';
+import { resolveOllamaBaseUrl } from '../shared/llm/ollama-url.js';
 const logger = LoggerFactory.create('local-judge');
 const DEFAULT_URL = 'http://localhost:11434';
 const DEFAULT_MODEL = 'qwen3:8b';
@@ -46,7 +47,7 @@ export class LocalJudgeClient {
     model;
     enabled;
     constructor(opts) {
-        this.baseUrl = opts?.url ?? process.env['NAGUAL_JUDGE_URL'] ?? DEFAULT_URL;
+        this.baseUrl = opts?.url ?? process.env['NAGUAL_JUDGE_URL'] ?? resolveOllamaBaseUrl(DEFAULT_URL);
         this.model = opts?.model ?? process.env['NAGUAL_JUDGE_MODEL'] ?? DEFAULT_MODEL;
         // Only active when explicitly configured via env or constructor options
         this.enabled = Boolean(opts?.url ?? opts?.model ??

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

@@ -175,7 +175,7 @@ export interface IPatternStore {
     /** Search for patterns */
     search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
     /** Update pattern after use */
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     /** Promote pattern from short-term to long-term */
     promote(id: string): Promise<Result<void>>;
     /** Delete a pattern */
@@ -315,7 +315,7 @@ export declare class PatternStore implements IPatternStore {
     /**
      * Record pattern usage and update stats
      */
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     /**
      * Promote pattern from short-term to long-term storage
      */

package/dist/learning/pattern-store.js

@@ -436,7 +436,18 @@ export class PatternStore {
         // Persist to SQLite (pattern + embedding atomically)
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.storePattern(pattern, pattern.embedding);
+                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding);
+                // #447: ON CONFLICT(name, qe_domain, pattern_type) may preserve an
+                // existing row's id instead of the one we generated — realign the
+                // in-memory indices (and pattern.id itself) or every later
+                // recordUsage()/promote()/delete() call for this pattern throws
+                // "Pattern not found" against SQLite while silently succeeding
+                // in-memory, permanently desyncing usage stats from qe_pattern_usage.
+                if (actualId && actualId !== pattern.id) {
+                    this.unindexPattern(pattern);
+                    pattern.id = actualId;
+                    this.indexPattern(pattern);
+                }
             }
             catch (error) {
                 console.warn(`[PatternStore] SQLite persist failed for ${pattern.id}:`, toErrorMessage(error));
@@ -987,7 +998,7 @@ export class PatternStore {
     /**
      * Record pattern usage and update stats
      */
-    async recordUsage(id, success) {
+    async recordUsage(id, success, metrics, feedback) {
         const pattern = await this.get(id);
         if (!pattern) {
             return err(new Error(`Pattern not found: ${id}`));
@@ -1016,7 +1027,7 @@ export class PatternStore {
         // Persist usage to SQLite
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.recordUsage(id, success);
+                this.sqliteStore.recordUsage(id, success, metrics, feedback);
             }
             catch (error) {
                 console.warn(`[PatternStore] SQLite recordUsage failed for ${id}:`, toErrorMessage(error));

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

@@ -343,16 +343,12 @@ export class QEReasoningBank {
         if (!this.config.enableLearning) {
             return ok(undefined);
         }
-        const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success);
-        // Persist usage to SQLite (updates qe_patterns row AND inserts qe_pattern_usage)
-        try {
-            const store = this.getSqliteStore();
-            store.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
-        }
-        catch (persistError) {
-            // Non-critical — don't fail if persistence fails
-            logger.warn('SQLite pattern usage persist failed', { error: toErrorMessage(persistError) });
-        }
+        // Single writer (#486 Gap B): patternStore.recordUsage() persists to SQLite
+        // itself (updates qe_patterns row AND inserts qe_pattern_usage) when a
+        // SQLitePatternStore is wired via setSqliteStore(). A second explicit
+        // SQLite write here previously double-counted every outcome — two
+        // qe_pattern_usage rows and a +2 usage_count for one recordOutcome() call.
+        const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
         if (result.success) {
             this.stats.learningOutcomes++;
             if (outcome.success) {
@@ -608,9 +604,18 @@ export class QEReasoningBank {
         // 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.
+        // routing_outcomes / qe_pattern_usage rows exist.
+        //
+        // routing_outcomes / qe_pattern_usage are written synchronously on every
+        // recordOutcome()/routeTask() call, so the DB aggregate is always a
+        // superset of (>=) the in-memory counters for this process. Previously
+        // this only consulted the DB when the in-memory counter was exactly
+        // zero, which made reported totals regress the moment in-memory ticked
+        // past zero mid-session — a cold-start call would correctly report the
+        // historical DB total, then the very next call after one recordOutcome()
+        // would drop to reporting just "1" instead of "historical total + 1".
+        // Taking the max keeps the number monotonic while still tolerating a
+        // failed/unavailable DB aggregate (falls back to in-memory).
         let routingRequests = this.stats.routingRequests;
         let avgRoutingConfidence = this.stats.routingRequests > 0
             ? this.stats.totalRoutingConfidence / this.stats.routingRequests
@@ -619,27 +624,25 @@ export class QEReasoningBank {
         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;
-                }
+        try {
+            const agg = this.getSqliteStore().getAggregateOutcomeStats();
+            if (agg.routingRequests > routingRequests) {
+                routingRequests = agg.routingRequests;
+                avgRoutingConfidence = agg.avgRoutingConfidence;
             }
-            catch {
-                // best-effort — never let stats reporting crash the host
+            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;
             }
         }
+        catch {
+            // best-effort — never let stats reporting crash the host
+        }
         return {
             totalPatterns: patternStoreStats.totalPatterns,
             byDomain,

package/dist/learning/routing-topology-gate.d.ts

@@ -20,8 +20,18 @@
  *    permanently dampened in the exact deployment case ADR-095 was meant
  *    to help.
  *
- * Treat empty/uninitialized graph as "no signal" (full ε rate). Only
- * consult `isCritical()` when the graph has actual vertices.
+ *    A16 correction (2026-07-06): `graph.isEmpty()` alone doesn't catch
+ *    this — `QueenMinCutBridge` always seeds ~14 `domain:*` scaffold
+ *    vertices + workflow edges on init, so `isEmpty()` is false as soon as
+ *    Queen starts, even with zero real agents ever spawned. The mincut
+ *    over those scaffold-only edges (one-directional, `defect-intelligence`
+ *    a pure sink) computes to exactly 0.0 — still degenerate, still
+ *    "critical" by the threshold check. Check for real `agent:*` vertices
+ *    specifically (same fix `QueenMinCutBridge.isEmptyTopology()` already
+ *    applies internally), not raw vertex count.
+ *
+ * Treat a graph with no real agent vertices as "no signal" (full ε rate).
+ * Only consult `isCritical()` once at least one agent has actually spawned.
  */
 /**
  * Returns true ONLY when:

package/dist/learning/routing-topology-gate.js

@@ -20,8 +20,18 @@
  *    permanently dampened in the exact deployment case ADR-095 was meant
  *    to help.
  *
- * Treat empty/uninitialized graph as "no signal" (full ε rate). Only
- * consult `isCritical()` when the graph has actual vertices.
+ *    A16 correction (2026-07-06): `graph.isEmpty()` alone doesn't catch
+ *    this — `QueenMinCutBridge` always seeds ~14 `domain:*` scaffold
+ *    vertices + workflow edges on init, so `isEmpty()` is false as soon as
+ *    Queen starts, even with zero real agents ever spawned. The mincut
+ *    over those scaffold-only edges (one-directional, `defect-intelligence`
+ *    a pure sink) computes to exactly 0.0 — still degenerate, still
+ *    "critical" by the threshold check. Check for real `agent:*` vertices
+ *    specifically (same fix `QueenMinCutBridge.isEmptyTopology()` already
+ *    applies internally), not raw vertex count.
+ *
+ * Treat a graph with no real agent vertices as "no signal" (full ε rate).
+ * Only consult `isCritical()` once at least one agent has actually spawned.
  */
 import { getSharedMinCutGraph, getSharedMinCutMonitor, isSharedMinCutGraphInitialized, isSharedMinCutMonitorInitialized, } from '../coordination/mincut/shared-singleton.js';
 /**
@@ -44,7 +54,9 @@ export function resolveTopologyCriticalFromSharedMincut() {
         if (!isSharedMinCutGraphInitialized())
             return false;
         const graph = getSharedMinCutGraph();
-        if (graph.isEmpty())
+        // Domain-coordinator scaffold vertices/edges are always present once
+        // Queen initializes; they don't count as "the graph has real signal".
+        if (graph.getVerticesByType('agent').length === 0)
             return false;
         return getSharedMinCutMonitor().isCritical();
     }

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

@@ -63,7 +63,7 @@ export declare class RvfPatternStore implements IPatternStore {
     create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
     get(id: string): Promise<QEPattern | null>;
     search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     promote(id: string): Promise<Result<void>>;
     delete(id: string): Promise<Result<void>>;
     getStats(): Promise<PatternStoreStats>;

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

@@ -372,12 +372,12 @@ export class RvfPatternStore {
     // --------------------------------------------------------------------------
     // IPatternStore — Mutation operations
     // --------------------------------------------------------------------------
-    async recordUsage(id, success) {
+    async recordUsage(id, success, metrics, feedback) {
         if (!this.sqliteStore) {
             return err(new Error('No SQLite store attached'));
         }
         try {
-            this.sqliteStore.recordUsage(id, success);
+            this.sqliteStore.recordUsage(id, success, metrics, feedback);
             return ok(undefined);
         }
         catch (error) {
@@ -419,18 +419,31 @@ export class RvfPatternStore {
     }
     async getStats() {
         const rvfStatus = this.adapter?.status();
-        // Get pattern count from RVF if available, otherwise fall back to SQLite
-        let totalPatterns = rvfStatus?.totalVectors ?? 0;
-        if (totalPatterns === 0 && this.sqliteStore) {
+        // qe_patterns (SQLite) is the source of truth for pattern count and
+        // domain/tier breakdown — the RVF vector index only covers patterns
+        // that have actually been embedded, and is reported separately via
+        // hnswStats.vectorCount. Previously this used RVF's totalVectors as the
+        // headline count, which silently hid any pattern stored without a
+        // matching embedding (#553).
+        let totalPatterns = 0;
+        let byDomain = {};
+        let byTier = { shortTerm: 0, longTerm: 0 };
+        if (this.sqliteStore) {
             try {
-                totalPatterns = this.sqliteStore.getStats().totalPatterns;
+                const sqliteStats = this.sqliteStore.getStats();
+                totalPatterns = sqliteStats.totalPatterns;
+                byDomain = sqliteStats.byDomain;
+                byTier = {
+                    shortTerm: sqliteStats.byTier['short-term'] ?? 0,
+                    longTerm: sqliteStats.byTier['long-term'] ?? 0,
+                };
             }
             catch { /* best effort */ }
         }
         return {
             totalPatterns,
-            byTier: { shortTerm: 0, longTerm: 0 },
-            byDomain: {},
+            byTier,
+            byDomain,
             byType: {},
             avgConfidence: 0,
             avgQualityScore: 0,

package/dist/learning/sqlite-persistence.js

@@ -391,24 +391,27 @@ export class SQLitePatternStore {
         if (!insertPattern || !insertEmbedding) {
             throw new Error('Prepared statements not ready');
         }
+        let actualId = id;
         // Use transaction for atomicity
         const transaction = this.db.transaction(() => {
             insertPattern.run(id, pattern.patternType, pattern.qeDomain, pattern.domain, pattern.name, pattern.description || '', pattern.confidence, pattern.tier || 'short-term', JSON.stringify(pattern.template), JSON.stringify(pattern.context));
+            // #447: ON CONFLICT(name, qe_domain, pattern_type) preserves the
+            // existing row's id instead of `id`. Resolve the actual id BEFORE
+            // inserting the embedding — qe_pattern_embeddings.pattern_id has a
+            // FOREIGN KEY on qe_patterns(id), so inserting under the discarded
+            // `id` (no such row) throws "FOREIGN KEY constraint failed".
+            const actualRow = this.db
+                .prepare('SELECT id FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?')
+                .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
+            actualId = actualRow ? actualRow.id : id;
             if (embedding) {
                 // Store embedding as BLOB (Float32Array)
                 const buffer = Buffer.from(new Float32Array(embedding).buffer);
-                insertEmbedding.run(id, buffer, embedding.length, 'all-MiniLM-L6-v2');
+                insertEmbedding.run(actualId, buffer, embedding.length, 'all-MiniLM-L6-v2');
             }
         });
         transaction();
-        // #447: ON CONFLICT(name, qe_domain, pattern_type) preserves the existing
-        // row's id, so the new `id` we just tried to insert may not be what's
-        // actually stored. SELECT the actual id back so callers (rvf-pattern-store,
-        // qe-hooks) can stay consistent with HNSW and downstream usage tables.
-        const actualRow = this.db
-            .prepare('SELECT id FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?')
-            .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
-        return actualRow ? actualRow.id : id;
+        return actualId;
     }
     /**
      * Get a pattern by ID