agentic-qe 3.15.10 → 3.15.12

package/dist/domains/test-generation/coordinator.js

@@ -9,7 +9,7 @@
  */
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import { readFile } from 'node:fs/promises';
+import { readConfinedText } from '../../shared/io/confined-read.js';
 import { ok, err, } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
 // Opt-in free-tier local test generation (cross-pollination plan 06, D7-wire/D8/D9).
@@ -425,7 +425,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             return null;
         let code = '';
         try {
-            code = await readFile(src, 'utf8');
+            code = await readConfinedText(src, { outsideRoot: 'allow' }); // #1161
         }
         catch {
             return null; // unreadable → fall back

package/dist/domains/test-generation/services/pattern-matcher.js

@@ -7,7 +7,7 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import ts from 'typescript';
-import * as fs from 'fs';
+import { readConfinedTextSync } from '../../../shared/io/confined-read.js';
 import * as path from 'path';
 import { ok, err } from '../../../shared/types/index.js';
 import { NomicEmbedder, EMBEDDING_CONFIG } from '../../../shared/embeddings/index.js';
@@ -45,7 +45,7 @@ export class PatternMatcherService {
             // Read file content
             let content;
             try {
-                content = fs.readFileSync(filePath, 'utf-8');
+                content = readConfinedTextSync(filePath, { outsideRoot: 'allow' }); // #1161
             }
             catch {
                 return err(new Error(`Cannot read file: ${filePath}`));
@@ -737,7 +737,7 @@ export class PatternMatcherService {
             // Read the file content
             let content;
             try {
-                content = fs.readFileSync(file, 'utf-8');
+                content = readConfinedTextSync(file, { outsideRoot: 'allow' }); // #1161
             }
             catch {
                 // File doesn't exist or can't be read, return empty
@@ -1068,7 +1068,7 @@ class TypeScriptASTParser {
             this.sourceCode = content;
         }
         else {
-            this.sourceCode = fs.readFileSync(filePath, 'utf-8');
+            this.sourceCode = readConfinedTextSync(filePath, { outsideRoot: 'allow' }); // #1161
         }
         this.sourceFile = ts.createSourceFile(path.basename(filePath), this.sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
         return this.sourceFile;

package/dist/domains/test-generation/services/test-generator.js

@@ -10,7 +10,7 @@ import { generateBehaviorExamples } from './behavior-examples.js';
 import { validateBehaviorExamples } from './behavior-example-validation.js';
 import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import * as fs from 'fs';
+import { readConfinedTextSync } from '../../../shared/io/confined-read.js';
 import * as path from 'path';
 import ts from 'typescript';
 import { ok, err } from '../../../shared/types/index.js';
@@ -445,7 +445,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         let codeAnalysis = null;
         let sourceContent = '';
         try {
-            sourceContent = fs.readFileSync(sourceFile, 'utf-8');
+            sourceContent = readConfinedTextSync(sourceFile, { outsideRoot: 'allow' }); // #1161
             codeAnalysis = await this.analyzeSourceCode(sourceContent, sourceFile);
         }
         catch {

package/dist/governance/evolution-pipeline-integration.js

@@ -19,6 +19,7 @@
 import { governanceFlags } from './feature-flags.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 // ============================================================================
 // Feature Flag Helpers
 // ============================================================================
@@ -799,7 +800,8 @@ export class EvolutionPipelineIntegration {
      * Group array by key function
      */
     groupBy(array, keyFn) {
-        const groups = {};
+        // #1157: keys come from recorded rule applications.
+        const groups = createSafeRecord();
         for (const item of array) {
             const key = keyFn(item);
             if (!groups[key]) {

package/dist/hooks/cross-phase-hooks.js

@@ -12,6 +12,7 @@ import { join } from 'path';
 import { parse as parseYaml } from 'yaml';
 import { getCrossPhaseMemory, } from '../memory/cross-phase-memory.js';
 import { captureHooksConfigSnapshot, validateHookUrl, classifyHookExit, } from './security/index.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 // =============================================================================
 // Hook Executor
 // =============================================================================
@@ -79,7 +80,8 @@ export class CrossPhaseHookExecutor {
         // IMP-07: Runtime kill-switch check
         if (process.env.AQE_HOOKS_DISABLED === 'true')
             return {};
-        const injectedSignals = {};
+        // #1157: agent names come from the hooks YAML file.
+        const injectedSignals = createSafeRecord();
         const matchingHooks = this.filterManagedHooks(Object.entries(this.config.hooks).filter(([_, hook]) => hook.trigger.event === 'phase-start' &&
             hook.trigger.phase === phaseName));
         for (const [hookName, hook] of matchingHooks) {

package/dist/init/init-wizard-steps.js

@@ -11,6 +11,7 @@ import { createSkillsInstaller } from './skills-installer.js';
 import { createAgentsInstaller } from './agents-installer.js';
 import { createN8nInstaller } from './n8n-installer.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { isNativeModuleLoadFailure, withNativeModuleRemedy } from '../shared/native-module-errors.js';
 import { openDatabase } from '../shared/safe-db.js';
 import { safeJsonParse } from '../shared/safe-json.js';
 // ============================================================================
@@ -112,7 +113,7 @@ export async function initializePersistenceDatabase(projectRoot) {
         const mod = await import('better-sqlite3');
         Database = mod.default;
     }
-    catch (error) {
+    catch {
         throw new Error('SQLite persistence REQUIRED but better-sqlite3 is not installed.\n' +
             'Install it with: npm install better-sqlite3\n' +
             'If you see native compilation errors, ensure build tools are installed:\n' +
@@ -157,6 +158,9 @@ export async function initializePersistenceDatabase(projectRoot) {
         return true;
     }
     catch (error) {
+        if (isNativeModuleLoadFailure(error)) {
+            throw new Error(`SQLite persistence initialization FAILED: ${toErrorMessage(withNativeModuleRemedy(error))}`, { cause: error });
+        }
         throw new Error(`SQLite persistence initialization FAILED: ${error}\n` +
             `Database path: ${dbPath}\n` +
             'Ensure the directory is writable and has sufficient disk space.');

package/dist/init/phases/04-database.js

@@ -17,6 +17,8 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { BasePhase, } from './phase-interface.js';
 import { getAQEVersion } from '../types.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { isNativeModuleLoadFailure, withNativeModuleRemedy } from '../../shared/native-module-errors.js';
 /**
  * Database phase - initializes SQLite persistence via UnifiedMemoryManager
  */
@@ -106,6 +108,11 @@ export class DatabasePhase extends BasePhase {
             };
         }
         catch (error) {
+            // A native-addon load failure (#1173) is not a disk/permission problem:
+            // report the cause and the install fix instead of the generic advice.
+            if (isNativeModuleLoadFailure(error)) {
+                throw new Error(`SQLite persistence initialization FAILED: ${toErrorMessage(withNativeModuleRemedy(error))}`, { cause: error });
+            }
             throw new Error(`SQLite persistence initialization FAILED: ${error}\n` +
                 `Database path: ${dbPath}\n` +
                 'Ensure the directory is writable and has sufficient disk space.');

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/init/phases/12-verification.js

@@ -13,6 +13,8 @@ import { BasePhase, } from './phase-interface.js';
 import { openDatabase } from '../../shared/safe-db.js';
 /** The `# <ISO timestamp>` header line written by configToYAML(). */
 const CONFIG_TIMESTAMP_LINE = /^# \d{4}-\d{2}-\d{2}T[\d:.]+Z$/;
+/** #1157: config keys that would reach Object.prototype through a plain object. */
+const UNSAFE_YAML_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 /**
  * Verification phase - verifies installation and writes markers
  */
@@ -173,8 +175,12 @@ export class VerificationPhase extends BasePhase {
                 // Top-level key (no indentation)
                 const topMatch = line.match(/^(\w+):\s*(.*)$/);
                 if (topMatch) {
-                    currentSection = topMatch[1];
+                    // #1157: keys come from config.yaml; a `__proto__` section (and
+                    // everything under it) is skipped instead of re-prototyping result.
+                    currentSection = UNSAFE_YAML_KEYS.has(topMatch[1]) ? '' : topMatch[1];
                     currentSubSection = '';
+                    if (!currentSection)
+                        continue;
                     const value = topMatch[2].trim();
                     if (value && !value.startsWith('"')) {
                         // Simple value
@@ -191,9 +197,11 @@ export class VerificationPhase extends BasePhase {
                 // Second-level key (2-space indent)
                 const subMatch = line.match(/^ {2}(\w+):\s*(.*)$/);
                 if (subMatch && currentSection) {
-                    currentSubSection = subMatch[1];
+                    currentSubSection = UNSAFE_YAML_KEYS.has(subMatch[1]) ? '' : subMatch[1];
+                    if (!currentSubSection)
+                        continue;
                     const value = subMatch[2].trim();
-                    if (!result[currentSection]) {
+                    if (!Object.hasOwn(result, currentSection) || !result[currentSection]) {
                         result[currentSection] = {};
                     }
                     if (value) {
@@ -210,8 +218,10 @@ export class VerificationPhase extends BasePhase {
                 if (thirdMatch && currentSection && currentSubSection) {
                     const key = thirdMatch[1];
                     const value = thirdMatch[2].trim();
+                    if (UNSAFE_YAML_KEYS.has(key))
+                        continue;
                     const section = result[currentSection];
-                    if (!section[currentSubSection]) {
+                    if (!Object.hasOwn(section, currentSubSection) || !section[currentSubSection]) {
                         section[currentSubSection] = {};
                     }
                     if (typeof section[currentSubSection] === 'object' && !Array.isArray(section[currentSubSection])) {

package/dist/init/settings-merge.js

@@ -8,6 +8,7 @@
  * - Generates full env vars and v3 settings sections
  */
 import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { getOwn, setOwn } from '../shared/utils/safe-record.js';
 /**
  * Create a one-time `.backup` of an existing settings.json before AQE modifies
  * it — mirroring the CLAUDE.md backup convention.
@@ -75,22 +76,24 @@ export function isAqeHookEntry(entry) {
  * 3. Preserve any hook types not in the new config
  */
 export function mergeHooksSmart(existingHooks, newAqeHooks) {
+    // #1157: hook types come from the user's settings.json; read and write own
+    // entries only, so a type named `constructor` or `__proto__` is kept as-is.
     const merged = {};
     // Process hook types that have new AQE entries
     for (const [hookType, newEntries] of Object.entries(newAqeHooks)) {
-        const existing = existingHooks[hookType] || [];
+        const existing = getOwn(existingHooks, hookType) || [];
         // Keep only non-AQE entries from existing config
         const userEntries = Array.isArray(existing)
             ? existing.filter((entry) => !isAqeHookEntry(entry))
             : [];
         // New AQE hooks go after user hooks (except PreToolUse guard which should be first)
-        merged[hookType] = [...newEntries, ...userEntries];
+        setOwn(merged, hookType, [...newEntries, ...userEntries]);
     }
     // Preserve hook types that are not in our new config (user's custom hook types)
     for (const [hookType, hookArray] of Object.entries(existingHooks)) {
-        if (!merged[hookType]) {
+        if (!Object.hasOwn(merged, hookType)) {
             // This hook type isn't one we manage — keep it as-is
-            merged[hookType] = hookArray;
+            setOwn(merged, hookType, hookArray);
         }
     }
     return merged;

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,6 +124,13 @@ export declare class ExperienceReplay {
     private prepared;
     private initialized;
     private initializationPromise;
+    /**
+     * #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;
@@ -150,6 +168,17 @@ export declare class ExperienceReplay {
      * @returns The stored experience
      */
     storeExperience(trajectory: Trajectory, strategy: string, tags?: string[]): Promise<Experience | null>;
+    /**
+     * #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,6 +61,13 @@ export class ExperienceReplay {
     prepared = new Map();
     initialized = false;
     initializationPromise = null;
+    /**
+     * #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
@@ -81,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
@@ -399,7 +412,7 @@ export class ExperienceReplay {
             .map(s => scrubReasoningBlocks(s.action));
         // Generate embedding for similarity search
         const embeddingText = `${task} ${strategy} ${keyActions.join(' ')}`;
-        const embedding = await computeRealEmbedding(embeddingText, this.config.embedding);
+        const embedding = (await this.embedOrNull(embeddingText)) ?? undefined;
         const id = uuidv4();
         const domain = trajectory.domain || 'test-generation';
         const experience = {
@@ -456,6 +469,40 @@ export class ExperienceReplay {
         }
         return experience;
     }
+    /**
+     * #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 {
+            const embedding = await computeRealEmbedding(text, this.config.embedding);
+            this.embedderWorked = true;
+            return embedding;
+        }
+        catch (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
      *
@@ -465,9 +512,19 @@ export class ExperienceReplay {
      */
     async getGuidance(task, domain) {
         this.ensureInitialized();
+        // #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) {
@@ -478,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) {
@@ -546,7 +607,10 @@ export class ExperienceReplay {
         // Generate embedding for the task
         // ADR-099: scrub so query embeddings match the scrubbed stored embeddings
         task = scrubReasoningBlocks(task);
-        const taskEmbedding = await computeRealEmbedding(task, this.config.embedding);
+        const taskEmbedding = await this.embedOrNull(task);
+        if (!taskEmbedding) {
+            return [];
+        }
         // Create query embedding for HNSW search
         const queryEmbedding = {
             vector: taskEmbedding,

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

@@ -15,9 +15,9 @@
  * - Automatic strategy recommendations
  * - Pattern quality improvement over time
  */
-import { RealQEReasoningBank, type RealQEReasoningBankConfig, type RealQEPatternSearchResult, type RealQERoutingRequest, type RealQERoutingResult, type LearningOutcome } from '../../../learning/real-qe-reasoning-bank.js';
+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
@@ -183,6 +183,13 @@ export declare class EnhancedReasoningBankAdapter {
         domain?: QEDomain;
         minSimilarity?: number;
     }): 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

@@ -297,6 +297,19 @@ export class EnhancedReasoningBankAdapter {
         this.ensureInitialized();
         return this.reasoningBank.searchQEPatterns(query, options);
     }
+    /** #1022: whether pattern search uses vectors or text matching only. */
+    getPatternSearchStatus() {
+        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/ruvector/filter-adapter.js

@@ -69,7 +69,8 @@ function resolveField(result, fieldPath) {
         for (const part of parts) {
             if (current === null || current === undefined)
                 break;
-            if (typeof current === 'object') {
+            // #1157: an inherited member such as `toString` is not a field.
+            if (typeof current === 'object' && Object.hasOwn(current, part)) {
                 current = current[part];
             }
             else {

package/dist/learning/dream/insight-generator.js

@@ -14,6 +14,7 @@
  * @module learning/dream/insight-generator
  */
 import { randomUUID } from 'crypto';
+import { getOwn, setOwn } from '../../shared/utils/safe-record.js';
 /**
  * Default insight configuration
  */
@@ -320,10 +321,10 @@ export class InsightGenerator {
         };
         for (const node of activeNodes) {
             const typeKey = node.conceptType ?? 'pattern';
-            if (!byType[typeKey]) {
-                byType[typeKey] = [];
-            }
-            byType[typeKey].push(node);
+            // #1157: concept types come from stored nodes; own buckets only.
+            const bucket = getOwn(byType, typeKey) ?? [];
+            setOwn(byType, typeKey, bucket);
+            bucket.push(node);
         }
         // Gap: Error without resolution
         for (const errorNode of byType.error ?? []) {

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.
      */

package/dist/learning/embedder-endpoint-client.js

@@ -125,6 +125,10 @@ class CircuitBreaker {
         }
         return true;
     }
+    /** #1204: open (or re-open) the breaker for a full window from now. */
+    trip() {
+        this.trippedAt = Date.now();
+    }
     /** For tests / observability */
     getState() {
         return { open: this.isOpen(), failures: this.failures.length, trippedAt: this.trippedAt };
@@ -266,6 +270,22 @@ export class EmbedderEndpointClient {
     getBreakerState() {
         return this.breaker.getState();
     }
+    /**
+     * #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.
+     */
+    async probeThroughOpenBreaker() {
+        try {
+            return await this.probe();
+        }
+        catch (err) {
+            this.breaker.trip();
+            throw err;
+        }
+    }
     /**
      * Close the underlying keep-alive agent. Tests should call this in afterEach.
      */