agentic-qe 3.15.13 → 3.15.15

package/dist/integrations/agent-booster-wasm/index.d.ts

@@ -41,6 +41,14 @@ export interface TransformOptions {
     maxChunks?: number;
     allowFallback?: boolean;
 }
+/**
+ * Locate the wasm-bindgen glue (#1241). A relative require resolved against
+ * the bundle's directory (dist/mcp/ or dist/cli/chunks/), where the glue does
+ * not exist, so WASM never loaded from the published package. Look next to
+ * this module first (unbundled src/ or dist/), then in the copy the build
+ * places under dist/integrations/agent-booster-wasm/ in the package root.
+ */
+export declare function resolveWasmGlue(metaUrl?: string): string | null;
 /**
  * Map file extension to Language enum
  */

package/dist/integrations/agent-booster-wasm/index.js

@@ -8,7 +8,11 @@
  * Accuracy: 81% (13/16 test cases)
  */
 import { createRequire } from 'module';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { LoggerFactory } from '../../logging/index.js';
+import { findPackageRoot } from '../../init/find-package-root.js';
 const logger = LoggerFactory.create('agent-booster-wasm');
 // Language constants (const object instead of enum for ESM compatibility)
 // This pattern works consistently across tsx dev mode, node, and bundled builds
@@ -45,6 +49,21 @@ const LanguageNames = {
 let wasmModule = null;
 let wasmBooster = null;
 let loadError = null;
+const GLUE_FILE = 'agent_booster_wasm.js';
+/**
+ * Locate the wasm-bindgen glue (#1241). A relative require resolved against
+ * the bundle's directory (dist/mcp/ or dist/cli/chunks/), where the glue does
+ * not exist, so WASM never loaded from the published package. Look next to
+ * this module first (unbundled src/ or dist/), then in the copy the build
+ * places under dist/integrations/agent-booster-wasm/ in the package root.
+ */
+export function resolveWasmGlue(metaUrl = import.meta.url) {
+    const candidates = [join(dirname(fileURLToPath(metaUrl)), GLUE_FILE)];
+    const root = findPackageRoot(metaUrl);
+    if (root)
+        candidates.push(join(root, 'dist', 'integrations', 'agent-booster-wasm', GLUE_FILE));
+    return candidates.find((p) => existsSync(p)) ?? null;
+}
 /**
  * Load the WASM module
  */
@@ -54,9 +73,13 @@ async function loadWasm() {
     if (loadError)
         return false;
     try {
-        // Use createRequire for ESM compatibility
+        const gluePath = resolveWasmGlue();
+        if (!gluePath) {
+            throw new Error(`${GLUE_FILE} not found next to the module or under dist/integrations/agent-booster-wasm/`);
+        }
+        // The glue is CommonJS (it reads the .wasm via __dirname), so load it with require.
         const require = createRequire(import.meta.url);
-        wasmModule = require('./agent_booster_wasm.js');
+        wasmModule = require(gluePath);
         if (!wasmModule) {
             throw new Error('WASM module loaded but is null');
         }

package/dist/integrations/agent-booster-wasm/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "agent-booster-wasm",
+  "collaborators": [
+    "Agent Booster Team"
+  ],
+  "description": "WebAssembly bindings for agent-booster",
+  "version": "0.1.0",
+  "license": "MIT",
+  "files": [
+    "agent_booster_wasm_bg.wasm",
+    "agent_booster_wasm.js",
+    "agent_booster_wasm.d.ts"
+  ],
+  "main": "agent_booster_wasm.js",
+  "types": "agent_booster_wasm.d.ts"
+}

package/dist/integrations/ruvector/brain-rvf-exporter.d.ts

@@ -19,6 +19,8 @@ export interface RvfBrainManifest {
         readonly totalRecords?: number;
         /** Per-table row counts used by the recovery-mirror richness guard. */
         readonly tableCounts?: Readonly<Record<string, number>>;
+        /** Regenerable cache rows left out of the kernel, per table (#1238). */
+        readonly skippedCacheRows?: Readonly<Record<string, number>>;
     };
     readonly domains: readonly string[];
     readonly checksum: string;
@@ -48,6 +50,8 @@ export interface RvfBrainExportOptions {
     readonly signerKeyId?: string;
     /** Explicit operator acknowledgement that a richer existing mirror may be replaced. */
     readonly allowOverwriteRicher?: boolean;
+    /** Kernel size ceiling in bytes. Defaults to RVF_MAX_KERNEL_BYTES; lowered only by tests. */
+    readonly maxKernelBytes?: number;
 }
 export interface RvfBrainImportOptions {
     readonly mergeStrategy: MergeStrategy;
@@ -59,6 +63,27 @@ export interface RvfBrainImportResult {
     readonly conflicts: number;
     readonly embeddingsRestored: number;
 }
+/**
+ * Largest kernel image @ruvector/rvf-node accepts. One byte more and
+ * `embedKernel` fails with a misleading `RVF error 0x0303: FsyncFailed`
+ * (#1238; measured 134,217,728 B ok, 134,217,729 B fails).
+ */
+export declare const RVF_MAX_KERNEL_BYTES: number;
+/**
+ * Vector ids written by the code-intelligence domain (KG nodes, semantic code
+ * index, C4 diagrams). They are derived from source code and rebuilt by
+ * `aqe code index`, so they stay out of the brain kernel (#1238).
+ */
+export declare const CODE_INDEX_VECTOR_ID_PREFIX = "code-intelligence:";
+/** Thrown before any native call when the kernel would exceed the RVF limit. */
+export declare class RvfKernelTooLargeError extends Error {
+    readonly kernelBytes: number;
+    readonly limitBytes: number;
+    readonly tableBytes: Readonly<Record<string, number>>;
+    readonly complete: boolean;
+    readonly code = "RVF_KERNEL_TOO_LARGE";
+    constructor(kernelBytes: number, limitBytes: number, tableBytes: Readonly<Record<string, number>>, complete: boolean);
+}
 /** Export brain state to a single `.rvf` file with vector embeddings + kernel. */
 export declare function exportBrainToRvf(db: Database.Database, options: RvfBrainExportOptions, sourceDbLabel?: string): RvfBrainManifest;
 /** Import brain state from a `.rvf` file into a SQLite database. */

package/dist/integrations/ruvector/brain-rvf-exporter.js

@@ -9,6 +9,54 @@ import { createRvfStore, openRvfStore, openRvfStoreReadonly, isRvfNativeAvailabl
 import { sha256, tableExists, queryAll, domainFilterForColumn, runImportTransaction, mergeGenericRow, remapPatternReferences, mergeAppendOnlyRow, TABLE_CONFIGS, TABLE_BLOB_COLUMNS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, serializeRowBlobs, deserializeRowBlobs, } from './brain-shared.js';
 import { appendBrainImportWitness } from './brain-import-audit.js';
 // --- Export ---
+/**
+ * Largest kernel image @ruvector/rvf-node accepts. One byte more and
+ * `embedKernel` fails with a misleading `RVF error 0x0303: FsyncFailed`
+ * (#1238; measured 134,217,728 B ok, 134,217,729 B fails).
+ */
+export const RVF_MAX_KERNEL_BYTES = 128 * 1024 * 1024;
+/**
+ * Vector ids written by the code-intelligence domain (KG nodes, semantic code
+ * index, C4 diagrams). They are derived from source code and rebuilt by
+ * `aqe code index`, so they stay out of the brain kernel (#1238).
+ */
+export const CODE_INDEX_VECTOR_ID_PREFIX = 'code-intelligence:';
+const CODE_INDEX_VECTOR_MATCH = `substr(id, 1, ${CODE_INDEX_VECTOR_ID_PREFIX.length}) = ?`;
+function isCodeIndexVectorRow(tableName, row) {
+    if (tableName !== 'vectors')
+        return false;
+    const id = row.id;
+    return typeof id === 'string' && id.startsWith(CODE_INDEX_VECTOR_ID_PREFIX);
+}
+/** Thrown before any native call when the kernel would exceed the RVF limit. */
+export class RvfKernelTooLargeError extends Error {
+    kernelBytes;
+    limitBytes;
+    tableBytes;
+    complete;
+    code = 'RVF_KERNEL_TOO_LARGE';
+    constructor(kernelBytes, limitBytes, tableBytes, complete) {
+        const largest = Object.entries(tableBytes)
+            .filter(([, bytes]) => bytes >= 1024 * 1024)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([table, bytes]) => `${table} ${formatMb(bytes)}`)
+            .join(', ');
+        super(`RVF_KERNEL_TOO_LARGE: the brain kernel needs ${complete ? '' : 'at least '}` +
+            `${formatMb(kernelBytes)}, over the ${formatMb(limitBytes)} limit of the native RVF writer.` +
+            (largest ? ` Largest tables: ${largest}.` : '') +
+            ' Nothing was written. ' +
+            `Use --format jsonl (no size limit), or reduce the largest learning tables first.`);
+        this.kernelBytes = kernelBytes;
+        this.limitBytes = limitBytes;
+        this.tableBytes = tableBytes;
+        this.complete = complete;
+        this.name = 'RvfKernelTooLargeError';
+    }
+}
+function formatMb(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 /**
  * Sidecar suffixes that make up a complete store on disk. `''` is the store
  * itself; the adapter writes `.idmap.json` on close, and we write the manifest.
@@ -98,52 +146,93 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
     const tmpPath = `${outPath}.tmp.${process.pid}`;
     sweepStaleTmpFiles(outPath);
     removeStoreFiles(tmpPath);
-    // Create RVF container via adapter (handles idmap automatically)
-    const rvf = createRvfStore(tmpPath, dimension);
-    let closed = false;
-    try {
-        // --- Export all tables using TABLE_CONFIGS ---
-        const allTableData = {};
-        const domainSet = new Set();
-        let totalRecords = 0;
-        for (const config of TABLE_CONFIGS) {
-            const [where, params] = config.domainColumn
-                ? domainFilterForColumn(options.domains, config.domainColumn)
-                : [undefined, []];
-            let rows = queryAll(db, config.tableName, where, params);
-            if (options.domains && options.domains.length > 0) {
-                const manifestIds = new Set((allTableData.learning_evidence_manifests ?? []).map(row => row.id));
-                const patternIds = new Set((allTableData.qe_patterns ?? []).map(row => row.id));
-                if (['learning_evidence_segments', 'learning_segment_edges', 'learning_evidence_admissions'].includes(config.tableName)) {
-                    rows = rows.filter(row => manifestIds.has(row.manifest_id));
-                }
-                else if (config.tableName === 'pattern_manifest_lineage') {
-                    rows = rows.filter(row => {
-                        const lineage = row;
-                        return manifestIds.has(lineage.manifest_id) && patternIds.has(lineage.pattern_id);
-                    });
-                }
-                else if (config.tableName === 'pattern_segment_lineage') {
-                    rows = rows.filter(row => {
-                        const lineage = row;
-                        return manifestIds.has(lineage.manifest_id) && patternIds.has(lineage.pattern_id);
-                    });
-                }
+    // --- Serialize all tables using TABLE_CONFIGS, before any native call ---
+    // Issue #1238: the native writer has a hard kernel ceiling, so each table is
+    // serialized once and measured as it goes. An oversized brain fails here,
+    // without creating a store or spending time on the rest of the tables.
+    const maxKernelBytes = options.maxKernelBytes ?? RVF_MAX_KERNEL_BYTES;
+    const allTableData = {};
+    const tableJson = [];
+    const tableBytes = {};
+    const tableCounts = {};
+    const skippedCacheRows = {};
+    const domainSet = new Set();
+    let totalRecords = 0;
+    let kernelBytes = 0;
+    for (const config of TABLE_CONFIGS) {
+        let [where, params] = config.domainColumn
+            ? domainFilterForColumn(options.domains, config.domainColumn)
+            : [undefined, []];
+        if (config.tableName === 'vectors' && tableExists(db, 'vectors')) {
+            const { n } = db.prepare(`SELECT COUNT(*) AS n FROM vectors WHERE ${CODE_INDEX_VECTOR_MATCH}`).get(CODE_INDEX_VECTOR_ID_PREFIX);
+            if (n > 0)
+                skippedCacheRows.vectors = n;
+            where = `(id IS NULL OR NOT ${CODE_INDEX_VECTOR_MATCH})`;
+            params = [CODE_INDEX_VECTOR_ID_PREFIX];
+        }
+        let rows = queryAll(db, config.tableName, where, params);
+        if (options.domains && options.domains.length > 0) {
+            const manifestIds = new Set((allTableData.learning_evidence_manifests ?? []).map(row => row.id));
+            const patternIds = new Set((allTableData.qe_patterns ?? []).map(row => row.id));
+            if (['learning_evidence_segments', 'learning_segment_edges', 'learning_evidence_admissions'].includes(config.tableName)) {
+                rows = rows.filter(row => manifestIds.has(row.manifest_id));
             }
-            if (config.tableName === 'qe_patterns') {
-                for (const p of rows) {
-                    if (p.qe_domain)
-                        domainSet.add(p.qe_domain);
-                }
+            else if (config.tableName === 'pattern_manifest_lineage') {
+                rows = rows.filter(row => {
+                    const lineage = row;
+                    return manifestIds.has(lineage.manifest_id) && patternIds.has(lineage.pattern_id);
+                });
+            }
+            else if (config.tableName === 'pattern_segment_lineage') {
+                rows = rows.filter(row => {
+                    const lineage = row;
+                    return manifestIds.has(lineage.manifest_id) && patternIds.has(lineage.pattern_id);
+                });
             }
-            // Serialize BLOBs to Base64 for JSON storage
-            const blobCols = TABLE_BLOB_COLUMNS[config.tableName];
-            if (blobCols && blobCols.length > 0) {
-                rows = rows.map(r => serializeRowBlobs(r, blobCols));
+        }
+        if (config.tableName === 'qe_patterns') {
+            for (const p of rows) {
+                if (p.qe_domain)
+                    domainSet.add(p.qe_domain);
             }
+        }
+        // Serialize BLOBs to Base64 for JSON storage
+        const blobCols = TABLE_BLOB_COLUMNS[config.tableName];
+        if (blobCols && blobCols.length > 0) {
+            rows = rows.map(r => serializeRowBlobs(r, blobCols));
+        }
+        // Only these two tables are read back (domain-filtered lineage above).
+        if (config.tableName === 'qe_patterns' || config.tableName === 'learning_evidence_manifests') {
             allTableData[config.tableName] = rows;
-            totalRecords += rows.length;
         }
+        tableCounts[config.tableName] = rows.length;
+        totalRecords += rows.length;
+        const json = JSON.stringify(rows);
+        tableJson.push([config.tableName, json]);
+        tableBytes[config.tableName] = Buffer.byteLength(json);
+        kernelBytes += tableBytes[config.tableName];
+        if (kernelBytes > maxKernelBytes) {
+            throw new RvfKernelTooLargeError(kernelBytes, maxKernelBytes, tableBytes, false);
+        }
+    }
+    // Same bytes JSON.stringify would produce for { version, format, exportedAt,
+    // sourceDb, domains, tables }, assembled from the per-table JSON above.
+    const exportedAt = new Date().toISOString();
+    const domains = [...domainSet].sort();
+    const brainJson = `{"version":"3.0","format":"rvf","exportedAt":${JSON.stringify(exportedAt)},` +
+        `"sourceDb":${JSON.stringify(sourceDbLabel)},"domains":${JSON.stringify(domains)},"tables":{` +
+        tableJson.map(([tableName, json]) => `${JSON.stringify(tableName)}:${json}`).join(',') +
+        '}}';
+    tableJson.length = 0;
+    const kernelBuffer = Buffer.from(brainJson);
+    if (kernelBuffer.length > maxKernelBytes) {
+        throw new RvfKernelTooLargeError(kernelBuffer.length, maxKernelBytes, tableBytes, true);
+    }
+    const checksum = sha256(brainJson);
+    // Create RVF container via adapter (handles idmap automatically)
+    const rvf = createRvfStore(tmpPath, dimension);
+    let closed = false;
+    try {
         // --- Ingest vector embeddings into HNSW ---
         let embeddingCount = 0;
         const embeddingEntries = [];
@@ -175,17 +264,6 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
             embeddingCount = result.accepted;
         }
         // --- Embed full brain data as kernel ---
-        const brainData = {
-            version: '3.0',
-            format: 'rvf',
-            exportedAt: new Date().toISOString(),
-            sourceDb: sourceDbLabel,
-            domains: [...domainSet].sort(),
-            tables: allTableData,
-        };
-        const brainJson = JSON.stringify(brainData);
-        const checksum = sha256(brainJson);
-        const kernelBuffer = Buffer.from(brainJson);
         rvf.embedKernel(kernelBuffer);
         // Optional Ed25519 signing
         const signature = options.sign ? rvf.sign(kernelBuffer) ?? undefined : undefined;
@@ -199,18 +277,19 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
         const manifest = {
             version: '3.0',
             format: 'rvf',
-            exportedAt: brainData.exportedAt,
+            exportedAt,
             sourceDb: sourceDbLabel,
             stats: {
-                patternCount: (allTableData['qe_patterns'] || []).length,
+                patternCount: tableCounts['qe_patterns'] ?? 0,
                 embeddingCount,
-                qValueCount: (allTableData['rl_q_values'] || []).length,
-                dreamInsightCount: (allTableData['dream_insights'] || []).length,
-                witnessChainLength: (allTableData['witness_chain'] || []).length,
+                qValueCount: tableCounts['rl_q_values'] ?? 0,
+                dreamInsightCount: tableCounts['dream_insights'] ?? 0,
+                witnessChainLength: tableCounts['witness_chain'] ?? 0,
                 totalRecords,
-                tableCounts: Object.fromEntries(TABLE_CONFIGS.map(({ tableName }) => [tableName, allTableData[tableName]?.length ?? 0])),
+                tableCounts,
+                ...(Object.keys(skippedCacheRows).length > 0 ? { skippedCacheRows } : {}),
             },
-            domains: brainData.domains,
+            domains,
             checksum,
             rvfStatus: {
                 totalVectors: status.totalVectors,
@@ -243,7 +322,9 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
         if (existsSync(outPath) && !options.allowOverwriteRicher) {
             let existing;
             try {
-                existing = brainInfoFromRvf(outPath);
+                // Code-index vectors are no longer exported (#1238), so an older mirror
+                // that still holds them is compared on the rows both exports carry.
+                existing = readBrainInfo(outPath, true);
             }
             catch (error) {
                 if (hasReadableBrainKernel(outPath) || !isKnownUnusableRvfError(error)) {
@@ -468,6 +549,13 @@ export function importBrainFromRvf(db, rvfPath, options) {
 // --- Info ---
 /** Read brain info from an RVF file without importing. */
 export function brainInfoFromRvf(rvfPath) {
+    return readBrainInfo(rvfPath, false);
+}
+/**
+ * `excludeCodeIndex` drops code-index vector rows from `tableCounts`, which
+ * makes them comparable with the counts of a current export.
+ */
+function readBrainInfo(rvfPath, excludeCodeIndex) {
     if (!isRvfNativeAvailable()) {
         throw new Error('@ruvector/rvf-node is not available.');
     }
@@ -499,7 +587,12 @@ export function brainInfoFromRvf(rvfPath) {
         const tableCounts = t && typeof t === 'object' && !Array.isArray(t)
             ? Object.fromEntries(Object.entries(t)
                 .filter((entry) => Array.isArray(entry[1]))
-                .map(([tableName, rows]) => [tableName, rows.length]))
+                .map(([tableName, rows]) => [
+                tableName,
+                excludeCodeIndex
+                    ? rows.filter(row => !isCodeIndexVectorRow(tableName, row)).length
+                    : rows.length,
+            ]))
             : undefined;
         return {
             version: '3.0',

package/dist/learning/dream/dream-engine.d.ts

@@ -14,11 +14,18 @@
  *
  * @module learning/dream/dream-engine
  */
+/**
+ * #1239: how long retention waits for a locked database. better-sqlite3 waits
+ * synchronously, and retention is optional (the next dream retries), so it
+ * gives up quickly instead of using the engine's 60 s commit wait.
+ */
+export declare const RETENTION_BUSY_TIMEOUT_MS = 1000;
 import { type ActivationConfig } from './spreading-activation.js';
 import { type InsightConfig, type DreamInsight } from './insight-generator.js';
 import { type Branch, type ValidationResult, type ValidationThresholds } from './rvcow-branch-manager.js';
 import { type ComputedDream } from './dream-commit.js';
 import type { WitnessChain } from '../../audit/witness-chain.js';
+import { type DreamRetentionReport } from '../learning-retention.js';
 import type { DreamCycle, PatternImportData, FailureImportData, SuccessImportData } from './types.js';
 /**
  * Complete DreamEngine configuration
@@ -66,6 +73,12 @@ export interface DreamCycleResult {
     patternsCreated: number;
     /** #1060: how long the single commit transaction held the write lock, in ms. */
     commitDurationMs?: number;
+    /**
+     * #1239: dream retention after the commit, with row counts. Off by default
+     * (AQE_DREAM_RETENTION); while off, the steps are a dry run showing what
+     * they would remove.
+     */
+    retention?: DreamRetentionReport;
     /**
      * #1060: the uncommitted results of a `dream(…, { commit: false })` run.
      * Pass the result to DreamEngine.commitDreamResult() to write them.
@@ -199,11 +212,22 @@ export declare class DreamEngine {
      * #1060: write the results of a `dream(…, { commit: false })` run, in the
      * same single transaction a normal dream uses. Returns the commit duration
      * in ms. Throws (and writes nothing) if the engine is closed or the write
-     * fails.
+     * fails. #1253: async, because a locked database is retried without
+     * blocking the process.
+     */
+    commitDreamResult(result: DreamCycleResult): Promise<number>;
+    /**
+     * Commit a computed dream, then record it in the witness chain (#1060) and
+     * run the default retention steps (#1239).
      */
-    commitDreamResult(result: DreamCycleResult): number;
-    /** Commit a computed dream, then record it in the witness chain (#1060). */
     private commitComputed;
+    /**
+     * #1239: after a committed dream, drop failed cycles past their retention
+     * window and outcome concepts beyond the cap when AQE_DREAM_RETENTION=on;
+     * otherwise only count what that would remove. The dream is already
+     * committed, so a failure here (a locked database, say) is only logged.
+     */
+    private runDefaultRetention;
     /**
      * #1060: build a synchronous handler that stops a still-running dream and
      * records its cycle as 'interrupted'. It runs from close() and from a