agentic-qe 3.15.11 → 3.15.13

package/dist/domains/visual-accessibility/services/accessibility-tester.js

@@ -3,9 +3,10 @@
  * Implements WCAG 2.2 compliance auditing with browser mode support
  *
  * This service supports multiple modes of operation:
- * 1. Heuristic Mode (default): URL-pattern-based analysis without browser automation
- * 2. Browser Mode (agent-browser): Real DOM inspection via unified browser client
- * 3. Browser Mode (Vibium): Real DOM inspection via Vibium MCP integration
+ * 1. Browser Mode (agent-browser): Real DOM inspection via unified browser client
+ * 2. Browser Mode (Vibium): Real DOM inspection via Vibium MCP integration
+ * 3. Not measured: no browser could load the page. The report says so
+ *    (`measured: false`) and carries no findings (#1145).
  *
  * Browser mode provides more accurate results by:
  * - Running actual axe-core accessibility checks in the browser
@@ -15,7 +16,8 @@
  * Browser Client Integration:
  * - Prefers agent-browser when available (supports snapshots and axe-core injection)
  * - Falls back to Vibium if agent-browser unavailable
- * - Uses heuristic mode when no browser tool is available
+ * - Reports "not measured" when no browser tool could audit the page; it never
+ *   guesses findings from the URL (#1145)
  *
  * @module domains/visual-accessibility/services/accessibility-tester
  */
@@ -28,7 +30,7 @@ import { toError } from '../../../shared/error-utils.js';
 import { getBrowserClientForUseCase, } from '../../../integrations/browser/index.js';
 // Extracted modules
 import { WCAG_CRITERIA, getErrorMessage, auditWithBrowserClient, auditWithVibium, auditElementWithVibium, checkContrastWithVibium, checkKeyboardWithVibium, } from './accessibility-tester-browser.js';
-import { initializeRules, filterRulesByLevel, runRule, validateCriterion, analyzeContrastForElements, generateKeyboardReportWithHeuristics, hashUrl, } from './accessibility-tester-heuristics.js';
+import { initializeRules, filterRulesByLevel, runSimulatedRule, hashUrl, } from './accessibility-tester-heuristics.js';
 const DEFAULT_CONFIG = {
     defaultWCAGLevel: 'AA',
     includeWarnings: true,
@@ -109,28 +111,29 @@ export class AccessibilityTesterService {
     async audit(url, options) {
         try {
             const wcagLevel = options?.wcagLevel || this.config.defaultWCAGLevel;
+            const failures = [];
             if (this.shouldUseBrowserMode()) {
                 const browserClient = await this.getBrowserClient();
                 if (browserClient) {
                     const browserResult = await auditWithBrowserClient(browserClient, url, wcagLevel, this.config.browserConfig, options);
-                    if (browserResult.success) {
-                        await this.storeReport(browserResult.value);
-                        return browserResult;
-                    }
+                    if (browserResult.success)
+                        return await this.measuredReport(browserResult.value);
                     const errorMsg = getErrorMessage(browserResult);
+                    failures.push(errorMsg);
                     logger.warn(`Browser client audit failed: ${errorMsg}`);
                 }
                 if (this.vibiumClient && isBrowserModeEnabled() && isAxeCoreEnabled()) {
                     const vibiumResult = await auditWithVibium(this.vibiumClient, url, wcagLevel, this.config.browserConfig, options);
-                    if (vibiumResult.success) {
-                        await this.storeReport(vibiumResult.value);
-                        return vibiumResult;
-                    }
+                    if (vibiumResult.success)
+                        return await this.measuredReport(vibiumResult.value);
                     const errorMsg = getErrorMessage(vibiumResult);
-                    logger.warn(`Vibium audit failed, falling back to heuristic mode: ${errorMsg}`);
+                    failures.push(errorMsg);
+                    logger.warn(`Vibium audit failed; the page is not measured: ${errorMsg}`);
                 }
             }
-            return this.auditWithHeuristics(url, wcagLevel, options);
+            if (this.config.simulationMode)
+                return this.auditSimulated(url, wcagLevel, options);
+            return ok(this.notMeasuredReport(url, wcagLevel, this.notMeasuredReason(failures)));
         }
         catch (error) {
             return err(toError(error));
@@ -139,12 +142,10 @@ export class AccessibilityTesterService {
     async auditElement(url, selector) {
         if (this.shouldUseBrowserMode() && this.vibiumClient) {
             const browserResult = await auditElementWithVibium(this.vibiumClient, url, selector, this.config.defaultWCAGLevel, this.config.browserConfig);
-            if (browserResult.success) {
-                await this.storeReport(browserResult.value);
-                return browserResult;
-            }
+            if (browserResult.success)
+                return await this.measuredReport(browserResult.value);
             const errorMsg = getErrorMessage(browserResult);
-            logger.warn(`Browser mode element audit failed, falling back to heuristic mode: ${errorMsg}`);
+            logger.warn(`Browser mode element audit failed, falling back to a page audit: ${errorMsg}`);
         }
         return this.audit(url, {
             excludeSelectors: [],
@@ -152,9 +153,38 @@ export class AccessibilityTesterService {
         });
     }
     // ============================================================================
-    // Heuristic Audit
+    // Unmeasured Results (#1145)
     // ============================================================================
-    async auditWithHeuristics(url, wcagLevel, options) {
+    async measuredReport(report) {
+        const measured = { ...report, measured: true };
+        await this.storeReport(measured);
+        return ok(measured);
+    }
+    notMeasuredReason(failures) {
+        if (failures.length > 0)
+            return `no browser could audit the page (${failures.join('; ')})`;
+        if (!this.config.useBrowserMode)
+            return 'browser mode is disabled, and only a browser run measures a page';
+        return 'no browser is available (install agent-browser or connect Vibium) to load the page';
+    }
+    /** A report that says nothing was measured: no violations, no passes, no verdict. */
+    notMeasuredReport(url, wcagLevel, reason) {
+        return {
+            url,
+            timestamp: new Date(),
+            violations: [],
+            passes: [],
+            incomplete: filterRulesByLevel(this.rules, wcagLevel).map((rule) => ({
+                id: rule.id, description: rule.description, reason: 'Not measured: see notMeasuredReason', nodes: [],
+            })),
+            score: -1,
+            wcagLevel,
+            measured: false,
+            notMeasuredReason: reason,
+        };
+    }
+    /** Simulation mode: synthetic results, labelled unmeasured and never stored. */
+    async auditSimulated(url, wcagLevel, options) {
         try {
             const includeWarnings = options?.includeWarnings ?? this.config.includeWarnings;
             const applicableRules = includeWarnings
@@ -164,7 +194,7 @@ export class AccessibilityTesterService {
             const passes = [];
             const incomplete = [];
             for (const rule of applicableRules) {
-                const result = runRule(rule, { url }, this.config.simulationMode, this.config.enableColorContrastCheck);
+                const result = runSimulatedRule(rule, { url });
                 if (result.nodes.length > 0) {
                     violations.push({
                         id: rule.id,
@@ -192,19 +222,18 @@ export class AccessibilityTesterService {
                     });
                 }
             }
-            const totalChecks = applicableRules.length;
-            const failedChecks = violations.length;
-            const score = Math.round(((totalChecks - failedChecks) / totalChecks) * 100);
             const report = {
                 url,
                 timestamp: new Date(),
                 violations,
                 passes,
                 incomplete,
-                score,
+                // The synthetic score is not a measurement: -1, like every unmeasured score
+                score: -1,
                 wcagLevel,
+                measured: false,
+                notMeasuredReason: 'simulation mode: synthetic results, the page was not loaded',
             };
-            await this.storeReport(report);
             return ok(report);
         }
         catch (error) {
@@ -216,25 +245,19 @@ export class AccessibilityTesterService {
     // ============================================================================
     async checkContrast(url) {
         try {
-            const cacheKey = `visual-accessibility:contrast:${hashUrl(url)}`;
+            // v2 (#1145): never serve a guessed result cached by an earlier version.
+            const cacheKey = `visual-accessibility:contrast:v2:${hashUrl(url)}`;
             const cached = await this.memory.get(cacheKey);
             if (cached)
                 return ok(cached);
-            let analyses;
-            if (this.shouldUseBrowserMode() && this.vibiumClient) {
-                const browserResult = await checkContrastWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
-                if (browserResult.success) {
-                    analyses = browserResult.value;
-                }
-                else {
-                    const errorMsg = getErrorMessage(browserResult);
-                    logger.warn(`Browser mode contrast check failed, falling back to heuristic mode: ${errorMsg}`);
-                    analyses = analyzeContrastForElements(url);
-                }
+            if (!this.shouldUseBrowserMode() || !this.vibiumClient) {
+                return err(notMeasuredError('Color contrast', url, this.notMeasuredReason([])));
             }
-            else {
-                analyses = analyzeContrastForElements(url);
+            const browserResult = await checkContrastWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
+            if (!browserResult.success) {
+                return err(notMeasuredError('Color contrast', url, this.notMeasuredReason([getErrorMessage(browserResult)])));
             }
+            const analyses = browserResult.value;
             await this.memory.set(cacheKey, analyses, { namespace: 'visual-accessibility', ttl: 3600 });
             return ok(analyses);
         }
@@ -247,25 +270,23 @@ export class AccessibilityTesterService {
     // ============================================================================
     async validateWCAGLevel(url, level) {
         try {
-            const levelOrder = { A: 1, AA: 2, AAA: 3 };
-            const targetLevel = levelOrder[level];
-            const applicableCriteria = Object.values(WCAG_CRITERIA).filter((c) => levelOrder[c.level] <= targetLevel);
-            const failedCriteria = [];
-            const passedCriteria = [];
-            const urlHash = hashUrl(url);
-            const hashNum = parseInt(urlHash, 36);
-            for (const criterion of applicableCriteria) {
-                const ruleResult = validateCriterion(criterion, hashNum);
-                if (ruleResult.passed) {
-                    passedCriteria.push(criterion);
-                }
-                else {
-                    failedCriteria.push(criterion);
-                }
+            const audit = await this.audit(url, { wcagLevel: level, includeWarnings: true });
+            if (!audit.success)
+                return err(audit.error);
+            if (audit.value.measured !== true) {
+                return err(notMeasuredError(`WCAG ${level} validation`, url, audit.value.notMeasuredReason ?? 'not audited'));
             }
-            const passed = failedCriteria.length === 0;
+            const levelOrder = { A: 1, AA: 2, AAA: 3 };
+            const applicableCriteria = Object.values(WCAG_CRITERIA).filter((c) => levelOrder[c.level] <= levelOrder[level]);
+            const violated = new Set(audit.value.violations.flatMap((v) => v.wcagCriteria.map((c) => c.id)));
+            const failedCriteria = applicableCriteria.filter((c) => violated.has(c.id));
+            const passedCriteria = applicableCriteria.filter((c) => !violated.has(c.id));
             const score = Math.round((passedCriteria.length / applicableCriteria.length) * 100);
-            return ok({ level, passed, failedCriteria, passedCriteria, score });
+            return ok({
+                level, passed: failedCriteria.length === 0, failedCriteria, passedCriteria, score, measured: true,
+                limitations: ['A passed criterion means no automated axe-core check failed for it; ' +
+                        'keyboard operation, focus order and similar criteria still need manual review.'],
+            });
         }
         catch (error) {
             return err(toError(error));
@@ -276,25 +297,20 @@ export class AccessibilityTesterService {
     // ============================================================================
     async checkKeyboardNavigation(url) {
         try {
-            const cacheKey = `visual-accessibility:keyboard:${hashUrl(url)}`;
+            const cacheKey = `visual-accessibility:keyboard:v2:${hashUrl(url)}`;
             const cached = await this.memory.get(cacheKey);
             if (cached)
                 return ok(cached);
-            let report;
-            if (this.shouldUseBrowserMode() && this.config.enableKeyboardCheck && this.vibiumClient) {
-                const browserResult = await checkKeyboardWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
-                if (browserResult.success) {
-                    report = browserResult.value;
-                }
-                else {
-                    const errorMsg = getErrorMessage(browserResult);
-                    logger.warn(`Browser mode keyboard check failed, falling back to heuristic mode: ${errorMsg}`);
-                    report = generateKeyboardReportWithHeuristics(url);
-                }
+            if (!this.shouldUseBrowserMode() || !this.config.enableKeyboardCheck || !this.vibiumClient) {
+                const reason = this.config.enableKeyboardCheck
+                    ? this.notMeasuredReason([]) : 'the keyboard check is disabled';
+                return err(notMeasuredError('Keyboard navigation', url, reason));
             }
-            else {
-                report = generateKeyboardReportWithHeuristics(url);
+            const browserResult = await checkKeyboardWithVibium(this.vibiumClient, url, this.config.defaultWCAGLevel, this.config.browserConfig);
+            if (!browserResult.success) {
+                return err(notMeasuredError('Keyboard navigation', url, this.notMeasuredReason([getErrorMessage(browserResult)])));
             }
+            const report = browserResult.value;
             await this.memory.set(cacheKey, report, { namespace: 'visual-accessibility', ttl: 3600 });
             return ok(report);
         }
@@ -322,6 +338,9 @@ export class AccessibilityTesterService {
             if (!wcagResult.success) {
                 return err(new Error(`WCAG audit failed: ${wcagResult.error.message}`));
             }
+            if (wcagResult.value.measured !== true) {
+                return err(notMeasuredError('EU compliance', url, wcagResult.value.notMeasuredReason ?? 'not audited'));
+            }
             const euResult = await this.euComplianceService.validateCompliance(wcagResult.value, options);
             return euResult;
         }
@@ -348,4 +367,8 @@ export class AccessibilityTesterService {
         }
     }
 }
+/** #1145: an unmeasured check is an error with its reason, never an empty pass. */
+function notMeasuredError(check, url, reason) {
+    return new Error(`${check} NOT MEASURED for ${url}: ${reason}. No findings or verdict were produced.`);
+}
 //# sourceMappingURL=accessibility-tester.js.map

package/dist/init/phases/10-workers.js

@@ -173,6 +173,26 @@ if (workersSetting !== undefined && ['false', '0', 'off', 'no'].includes(workers
   process.exit(0);
 }
 
+// #1207: keep daemon.log bounded. The server truncates it on its heartbeat once
+// it passes AQE_DAEMON_LOG_MAX_SIZE (default 5M, 0 or off disables); a log left
+// over that size by an earlier run is moved to daemon.log.1 here, before
+// anything writes to it. rename() replaces daemon.log.1 and never follows it.
+function logMaxBytes() {
+  const text = String(process.env.AQE_DAEMON_LOG_MAX_SIZE || '').trim().toLowerCase();
+  if (['0', 'off', 'false', 'no', 'none', 'disable', 'disabled'].includes(text)) return 0;
+  const m = /^(\\d+)\\s*([kmg]?)b?$/.exec(text);
+  const bytes = m ? Number(m[1]) * { '': 1, k: 1024, m: 1048576, g: 1073741824 }[m[2]] : NaN;
+  return Number.isSafeInteger(bytes) && bytes >= 1024 ? bytes : 5 * 1048576;
+}
+function rotateLogAtStart(file) {
+  const max = logMaxBytes();
+  try {
+    const s = fs.lstatSync(file);
+    if (max > 0 && s.isFile() && s.size > max) fs.renameSync(file, file + '.1');
+  } catch {}
+}
+rotateLogAtStart(logFile);
+
 const ts = new Date().toISOString();
 appendFileSync(logFile, '[' + ts + '] Starting AQE v3 Worker Daemon...\\n');
 
@@ -228,10 +248,28 @@ if (binCandidate && binCandidate.endsWith('bundle.js')) {
 appendFileSync(logFile, '[' + ts + '] Using: ' + mcpCmd + ' ' + mcpArgs.join(' ') + '\\n');
 
 // #1066: keep a user's AQE_WORKERS_ENABLED (for example false) instead of forcing it on.
-const env = { ...process.env, AQE_STORAGE_PATH: '.agentic-qe', AQE_LEARNING_ENABLED: 'true', AQE_WORKERS_ENABLED: workersSetting ?? 'true', AQE_HTTP_PORT: '0' };
-const child = spawn(mcpCmd, mcpArgs, { cwd: projectRoot, env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
-child.stdout.on('data', d => appendFileSync(logFile, d));
-child.stderr.on('data', d => appendFileSync(logFile, d));
+// #1158: AQE_MCP_DAEMON=1 is daemon mode. The server has no stdin here, so
+// without it the stdin-EOF guard (#513) shut it down right after starting;
+// in daemon mode it stops only on SIGTERM/SIGINT (stop-daemon.cjs).
+const env = { ...process.env, AQE_STORAGE_PATH: '.agentic-qe', AQE_LEARNING_ENABLED: 'true', AQE_WORKERS_ENABLED: workersSetting ?? 'true', AQE_HTTP_PORT: '0', AQE_MCP_DAEMON: '1' };
+// #1158: the server writes daemon.log itself, through a descriptor opened
+// here with the same symlink rules as appendFileSync. Piping its output
+// through this script kept the script from exiting while the daemon ran, and
+// once the script was gone nothing was logged any more.
+function openLogFd(file) {
+  if (!isRegularOrAbsent(file)) return 'ignore';
+  const c = fs.constants;
+  try { return fs.openSync(file, c.O_APPEND | c.O_CREAT | c.O_WRONLY | (c.O_NOFOLLOW || 0), 0o644); } catch { return 'ignore'; }
+}
+const logFd = openLogFd(logFile);
+// #1207: name the file behind the server's stdout/stderr so it can rotate it.
+if (typeof logFd === 'number') env.AQE_MCP_DAEMON_LOG = logFile; else delete env.AQE_MCP_DAEMON_LOG;
+let child;
+try {
+  child = spawn(mcpCmd, mcpArgs, { cwd: projectRoot, env, detached: true, stdio: ['ignore', logFd, logFd] });
+} finally {
+  if (typeof logFd === 'number') { try { fs.closeSync(logFd); } catch {} }
+}
 let exited = null;
 child.on('exit', (code, signal) => { exited = { code, signal }; });
 // #1116: a command that cannot be started (no npx on PATH: spawn ENOENT) emits

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.d.ts

@@ -71,6 +71,15 @@ export interface ExperienceGuidance {
     /** Estimated token savings */
     readonly estimatedTokenSavings: number;
 }
+/**
+ * #1204: whether similar-experience guidance can use vectors. 'unavailable'
+ * means the embedder failed (or there is none): experiences are stored
+ * without vectors and getGuidance returns no guidance.
+ */
+export interface ExperienceGuidanceStatus {
+    mode: 'vector' | 'unavailable';
+    reason?: string;
+}
 /**
  * Configuration for ExperienceReplay
  */
@@ -89,6 +98,8 @@ export interface ExperienceReplayConfig {
     autoPrune: boolean;
     /** Prune threshold (quality below this is removed) */
     pruneThreshold: number;
+    /** #1204: after the embedder fails, wait this long before retrying it (default 60 s). */
+    embedderRetryIntervalMs?: number;
 }
 /**
  * ExperienceReplay stores and retrieves successful experiences for learning.
@@ -113,7 +124,13 @@ export declare class ExperienceReplay {
     private prepared;
     private initialized;
     private initializationPromise;
-    private embedderUnavailableLogged;
+    /**
+     * #1204: whether the embedder works; retried in the background after a
+     * failure, as the pattern banks do (#1187).
+     */
+    private readonly embedderRecovery;
+    /** Whether an embedding succeeded, to label later failures as runtime ones. */
+    private embedderWorked;
     private hnswIndex;
     private idToExperienceId;
     private experienceIdToHnswId;
@@ -155,8 +172,13 @@ export declare class ExperienceReplay {
      * #1022: embed text, or return null when no embedding runtime is available.
      * The experience is then stored without a vector (backfilled at a later
      * start that has an embedder) and similarity search finds no matches.
+     * #1204: a failure is reported by getEmbedderStatus(), labelled as a
+     * runtime failure when the embedder had worked, and warned about once per
+     * outage. The embedder is retried in the background after the interval.
      */
     private embedOrNull;
+    /** #1204: whether similar-experience guidance can use vectors, and if not why. */
+    getEmbedderStatus(): ExperienceGuidanceStatus;
     /**
      * Get guidance for a new task based on similar experiences
      *

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.js

@@ -14,7 +14,8 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { getUnifiedMemory } from '../../../kernel/unified-memory.js';
-import { computeRealEmbedding, } from '../../../learning/real-embeddings.js';
+import { computeRealEmbedding, cosineSimilarity, } from '../../../learning/real-embeddings.js';
+import { EmbedderRecovery, probeEmbedder } from '../../../learning/embedder-recovery.js';
 import { CircularBuffer } from '../../../shared/utils/circular-buffer.js';
 import { HNSWEmbeddingIndex } from '../../embeddings/index/HNSWIndex.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
@@ -60,7 +61,13 @@ export class ExperienceReplay {
     prepared = new Map();
     initialized = false;
     initializationPromise = null;
-    embedderUnavailableLogged = false;
+    /**
+     * #1204: whether the embedder works; retried in the background after a
+     * failure, as the pattern banks do (#1187).
+     */
+    embedderRecovery;
+    /** Whether an embedding succeeded, to label later failures as runtime ones. */
+    embedderWorked = false;
     // Real HNSW index for O(log n) similarity search (150x-12,500x faster than linear scan)
     hnswIndex;
     // Mapping from HNSW numeric IDs to experience string IDs
@@ -82,6 +89,11 @@ export class ExperienceReplay {
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.recentExperiences = new CircularBuffer(100);
+        this.embedderRecovery = new EmbedderRecovery({
+            retryIntervalMs: this.config.embedderRetryIntervalMs,
+            probe: () => probeEmbedder(this.config.embedding),
+            onRecovered: () => console.log('[ExperienceReplay] Embedder available again: similar-experience guidance uses vectors'),
+        });
         // Initialize real HNSW index with optimal parameters for experience search
         this.hnswIndex = new HNSWEmbeddingIndex({
             dimension: 384, // all-MiniLM-L6-v2 dimension
@@ -461,20 +473,36 @@ export class ExperienceReplay {
      * #1022: embed text, or return null when no embedding runtime is available.
      * The experience is then stored without a vector (backfilled at a later
      * start that has an embedder) and similarity search finds no matches.
+     * #1204: a failure is reported by getEmbedderStatus(), labelled as a
+     * runtime failure when the embedder had worked, and warned about once per
+     * outage. The embedder is retried in the background after the interval.
      */
     async embedOrNull(text) {
+        if (!this.embedderRecovery.isAvailable())
+            return null;
         try {
-            return await computeRealEmbedding(text, this.config.embedding);
+            const embedding = await computeRealEmbedding(text, this.config.embedding);
+            this.embedderWorked = true;
+            return embedding;
         }
         catch (error) {
-            if (!this.embedderUnavailableLogged) {
-                this.embedderUnavailableLogged = true;
-                console.warn('[ExperienceReplay] No embedding runtime; experiences are stored without vectors ' +
-                    'and similar-experience guidance is unavailable:', error instanceof Error ? error.message : error);
+            const message = error instanceof Error ? error.message : String(error);
+            const reason = this.embedderWorked ? `Embedder failed at runtime: ${message}` : message;
+            if (this.embedderRecovery.markUnavailable(reason)) {
+                console.warn(this.embedderWorked
+                    ? '[ExperienceReplay] Embedder failed; experiences are stored without vectors and ' +
+                        'similar-experience guidance is unavailable until it recovers:'
+                    : '[ExperienceReplay] No embedding runtime; experiences are stored without vectors ' +
+                        'and similar-experience guidance is unavailable:', message);
             }
             return null;
         }
     }
+    /** #1204: whether similar-experience guidance can use vectors, and if not why. */
+    getEmbedderStatus() {
+        const reason = this.embedderRecovery.unavailableReason;
+        return reason === null ? { mode: 'vector' } : { mode: 'unavailable', reason };
+    }
     /**
      * Get guidance for a new task based on similar experiences
      *
@@ -484,16 +512,19 @@ export class ExperienceReplay {
      */
     async getGuidance(task, domain) {
         this.ensureInitialized();
-        // #1022: the reservoir blend below picks experiences without looking at
-        // the query and gives them a coherence-derived similarity. Without an
-        // embedding of the query nothing measures relevance, so return no guidance
-        // rather than query-independent picks with a made-up similarity.
-        if (!(await this.embedOrNull(scrubReasoningBlocks(task)))) {
+        // #1022: without an embedding of the query nothing measures relevance, so
+        // return no guidance rather than picks with a made-up similarity.
+        const queryEmbedding = await this.embedOrNull(scrubReasoningBlocks(task));
+        if (!queryEmbedding) {
             return null;
         }
         // Find similar experiences via HNSW
         const similar = await this.findSimilarExperiences(task, domain);
-        // Blend in high-coherence experiences from reservoir buffer (R10, ADR-087)
+        // Blend in high-coherence experiences from reservoir buffer (R10, ADR-087).
+        // #1192: the buffer samples without looking at the query, so a sample is
+        // kept only when its similarity to the query embedding is measured and
+        // reaches the retrieval threshold. Samples without a comparable vector
+        // are skipped: every reported similarity is a measured one.
         if (this.reservoirBuffer && this.reservoirBuffer.size() > 0) {
             const reservoirSamples = this.reservoirBuffer.sample(Math.max(2, Math.floor(this.config.topK / 2)), 0.6);
             for (const entry of reservoirSamples) {
@@ -504,8 +535,12 @@ export class ExperienceReplay {
                 // Skip if domain filter doesn't match
                 if (domain && exp.domain !== domain)
                     continue;
-                // Add with a coherence-based similarity score
-                similar.push({ experience: exp, similarity: entry.coherenceScore * 0.8 });
+                if (!exp.embedding || exp.embedding.length !== queryEmbedding.length)
+                    continue;
+                const similarity = cosineSimilarity(queryEmbedding, exp.embedding);
+                if (similarity < this.config.similarityThreshold)
+                    continue;
+                similar.push({ experience: exp, similarity });
             }
         }
         if (similar.length === 0) {

package/dist/integrations/agentic-flow/reasoning-bank/index.d.ts

@@ -17,7 +17,7 @@
  */
 import { RealQEReasoningBank, type RealQEReasoningBankConfig, type RealQEPatternSearchResult, type PatternSearchStatus, type RealQERoutingRequest, type RealQERoutingResult, type LearningOutcome } from '../../../learning/real-qe-reasoning-bank.js';
 import { TrajectoryTracker, type Trajectory, type TrajectoryStep, type TrajectoryOptions, type TrajectoryTrackerConfig } from './trajectory-tracker.js';
-import { ExperienceReplay, type ExperienceGuidance, type ExperienceReplayConfig } from './experience-replay.js';
+import { ExperienceReplay, type ExperienceGuidance, type ExperienceGuidanceStatus, type ExperienceReplayConfig } from './experience-replay.js';
 import { PatternEvolution, type PatternVersion, type DriftDetectionResult, type MergeCandidate, type PatternEvolutionConfig } from './pattern-evolution.js';
 import type { QEPattern, QEDomain, CreateQEPatternOptions } from '../../../learning/qe-patterns.js';
 export interface EnhancedReasoningBankAdapterStats {
@@ -32,7 +32,7 @@ export interface EnhancedReasoningBankAdapterStats {
 }
 import type { Result } from '../../../shared/types/index.js';
 export { TrajectoryTracker, createTrajectoryTracker, type Trajectory, type TrajectoryStep, type TrajectoryOptions, type TrajectoryTrackerConfig, } from './trajectory-tracker.js';
-export { ExperienceReplay, createExperienceReplay, type Experience, type ExperienceGuidance, type ExperienceReplayConfig, } from './experience-replay.js';
+export { ExperienceReplay, createExperienceReplay, type Experience, type ExperienceGuidance, type ExperienceGuidanceStatus, type ExperienceReplayConfig, } from './experience-replay.js';
 export { PatternEvolution, createPatternEvolution, type PatternVersion, type DriftDetectionResult, type MergeCandidate, type PatternEvolutionConfig, } from './pattern-evolution.js';
 /**
  * Configuration for Enhanced ReasoningBank Adapter
@@ -185,6 +185,11 @@ export declare class EnhancedReasoningBankAdapter {
     }): Promise<Result<RealQEPatternSearchResult[]>>;
     /** #1022: whether pattern search uses vectors or text matching only. */
     getPatternSearchStatus(): PatternSearchStatus;
+    /**
+     * #1204: whether similar-experience guidance can use vectors; null when
+     * experience replay is disabled.
+     */
+    getExperienceGuidanceStatus(): ExperienceGuidanceStatus | null;
     /**
      * Record a pattern outcome with evolution tracking
      */

package/dist/integrations/agentic-flow/reasoning-bank/index.js

@@ -302,6 +302,14 @@ export class EnhancedReasoningBankAdapter {
         this.ensureInitialized();
         return this.reasoningBank.getPatternSearchStatus();
     }
+    /**
+     * #1204: whether similar-experience guidance can use vectors; null when
+     * experience replay is disabled.
+     */
+    getExperienceGuidanceStatus() {
+        this.ensureInitialized();
+        return this.experienceReplay?.getEmbedderStatus() ?? null;
+    }
     /**
      * Record a pattern outcome with evolution tracking
      */

package/dist/integrations/embeddings/index/HNSWIndex.js

@@ -10,6 +10,10 @@
  * @module integrations/embeddings/index/HNSWIndex
  */
 import { createRequire } from 'node:module';
+// Static import so the bundlers inline the adapter. A runtime
+// require('../../../kernel/hnsw-adapter.js') resolves against the bundle
+// file instead and fails, which silently capped the index at 10,000 (#1237).
+import { HnswAdapter } from '../../../kernel/hnsw-adapter.js';
 const require = createRequire(import.meta.url);
 let cachedHnswlibCtor = null;
 function loadHnswlibConstructor() {
@@ -70,8 +74,6 @@ export class HNSWEmbeddingIndex {
         // ADR-071: Route through unified HnswAdapter when flag is enabled
         if (this.useUnified && this.unifiedAdapters) {
             try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const { HnswAdapter } = require('../../../kernel/hnsw-adapter.js');
                 const adapter = new HnswAdapter(`embedding-${namespace}`, {
                     dimensions: this.config.dimension,
                     M: this.config.M,
@@ -84,8 +86,10 @@ export class HNSWEmbeddingIndex {
                 this.nextId.set(namespace, 0);
                 return;
             }
-            catch {
-                // Fall through to hnswlib-node
+            catch (error) {
+                // Fall through to hnswlib-node, which holds at most 10,000 entries.
+                console.warn(`[HNSWEmbeddingIndex] Unified HNSW adapter unavailable for '${namespace}', ` +
+                    `using the legacy index (max 10000 entries): ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         // Legacy path: hnswlib-node

package/dist/integrations/ruvector/transfer-coherence-stub.js

@@ -11,9 +11,11 @@
  *
  * @module integrations/ruvector/transfer-coherence-stub
  */
-import { createRequire } from 'module';
 import { getRuVectorFeatureFlags } from './feature-flags.js';
-const esmRequire = createRequire(import.meta.url);
+// Static import so the bundlers inline the gate. A runtime
+// require('./coherence-gate.js') resolves against the bundle file instead,
+// fails, and silently returned the approve-everything stub (#1237).
+import { CoherenceGate } from './coherence-gate-core.js';
 // ============================================================================
 // Stub Implementation
 // ============================================================================
@@ -49,14 +51,7 @@ export class TransferCoherenceStub {
  */
 export function createTransferCoherenceGate() {
     if (getRuVectorFeatureFlags().useCoherenceGate) {
-        try {
-            // Dynamic require to avoid circular dependency at module level
-            const { CoherenceGate } = esmRequire('./coherence-gate.js');
-            return new CoherenceGate();
-        }
-        catch {
-            // Fall through to stub if CoherenceGate fails to load
-        }
+        return new CoherenceGate();
     }
     return new TransferCoherenceStub();
 }

package/dist/learning/embedder-endpoint-client.d.ts

@@ -121,6 +121,14 @@ export declare class EmbedderEndpointClient {
         failures: number;
         trippedAt: number | null;
     };
+    /**
+     * #1204: probe the endpoint while the circuit breaker is open, as its single
+     * half-open trial. Other callers keep fast-failing meanwhile. A success
+     * closes the breaker and refreshes the identity; a failure keeps the
+     * breaker open for another full window. Lets a caller that rate-limits its
+     * own retries recover without also waiting out the breaker window.
+     */
+    probeThroughOpenBreaker(): Promise<EndpointIdentity>;
     /**
      * Close the underlying keep-alive agent. Tests should call this in afterEach.
      */