agentic-qe 3.10.1 → 3.10.2

package/dist/mcp/protocol-server.js

@@ -5,7 +5,7 @@
  *
  * ADR-039: Integrated with connection pooling, load balancing, and performance monitoring
  */
-import { createStdioTransport, JSON_RPC_ERRORS, } from './transport';
+import { createStdioTransport, JSON_RPC_ERRORS, isJsonRpcCodedError, McpError, } from './transport';
 import { createToolRegistry } from './tool-registry';
 import { MiddlewareChain } from './middleware/middleware-chain';
 import { createMicrocompactMiddleware } from './middleware/microcompact';
@@ -156,7 +156,15 @@ export class MCPProtocolServer {
                 return await this.handleRequest(request);
             }
             catch (err) {
-                // Last-resort safety net: catch anything that escapes handleToolsCall
+                // Errors that carry a JSON-RPC `code` (e.g. METHOD_NOT_FOUND for an
+                // unknown tool/method — thrown as McpError or a legacy plain
+                // `{ code, message }` object) are real protocol errors: re-throw so the
+                // transport serializes them as a proper JSON-RPC error response with the
+                // correct code/message, instead of flattening to "[object Object]".
+                if (isJsonRpcCodedError(err)) {
+                    throw err;
+                }
+                // Last-resort safety net: catch anything else that escapes handleToolsCall
                 // to prevent MCP connection from being killed (-32000)
                 const message = err instanceof Error ? err.message : String(err);
                 console.error(`[MCP] Unhandled error in request handler: ${message}`);
@@ -307,10 +315,7 @@ export class MCPProtocolServer {
                 return { pong: true };
             // Unknown method
             default:
-                throw {
-                    code: JSON_RPC_ERRORS.METHOD_NOT_FOUND,
-                    message: `Unknown method: ${method}`,
-                };
+                throw new McpError(JSON_RPC_ERRORS.METHOD_NOT_FOUND, `Unknown method: ${method}`);
         }
     }
     async handleNotification(notification) {
@@ -333,10 +338,7 @@ export class MCPProtocolServer {
     // ============================================================================
     async handleInitialize(params) {
         if (this.initialized) {
-            throw {
-                code: JSON_RPC_ERRORS.INVALID_REQUEST,
-                message: 'Server already initialized',
-            };
+            throw new McpError(JSON_RPC_ERRORS.INVALID_REQUEST, 'Server already initialized');
         }
         // Store client info
         if (params.clientInfo) {
@@ -371,10 +373,7 @@ export class MCPProtocolServer {
         const { name, arguments: args = {} } = params;
         const tool = this.tools.get(name);
         if (!tool) {
-            throw {
-                code: JSON_RPC_ERRORS.METHOD_NOT_FOUND,
-                message: `Unknown tool: ${name}`,
-            };
+            throw new McpError(JSON_RPC_ERRORS.METHOD_NOT_FOUND, `Unknown tool: ${name}`);
         }
         // ADR-039: Track tool invocation with performance monitoring
         const startTime = performance.now();

package/dist/mcp/transport/stdio.d.ts

@@ -43,6 +43,26 @@ export declare const JSON_RPC_ERRORS: {
     readonly INTERNAL_ERROR: -32603;
     readonly SERVER_ERROR: -32000;
 };
+/**
+ * Error subclass that carries a JSON-RPC error `code` so it can be surfaced as a
+ * proper JSON-RPC error response (instead of being flattened to "[object Object]").
+ * Mirrors the OAuthProviderError pattern used in the security layer.
+ */
+export declare class McpError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+/**
+ * Type guard for any thrown value that carries a JSON-RPC `code` + `message`.
+ * Accepts both the McpError subclass and legacy plain `{ code, message }` objects
+ * so existing throw sites continue to map to the right JSON-RPC error code.
+ */
+export declare function isJsonRpcCodedError(err: unknown): err is {
+    code: number;
+    message: string;
+    data?: unknown;
+};
 export declare class StdioTransport {
     private readonly inputStream;
     private readonly outputStream;

package/dist/mcp/transport/stdio.js

@@ -16,6 +16,32 @@ export const JSON_RPC_ERRORS = {
     INTERNAL_ERROR: -32603,
     SERVER_ERROR: -32000,
 };
+/**
+ * Error subclass that carries a JSON-RPC error `code` so it can be surfaced as a
+ * proper JSON-RPC error response (instead of being flattened to "[object Object]").
+ * Mirrors the OAuthProviderError pattern used in the security layer.
+ */
+export class McpError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'McpError';
+    }
+}
+/**
+ * Type guard for any thrown value that carries a JSON-RPC `code` + `message`.
+ * Accepts both the McpError subclass and legacy plain `{ code, message }` objects
+ * so existing throw sites continue to map to the right JSON-RPC error code.
+ */
+export function isJsonRpcCodedError(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        typeof err.code === 'number' &&
+        typeof err.message === 'string');
+}
 // ============================================================================
 // Stdio Transport Implementation
 // ============================================================================
@@ -205,8 +231,15 @@ export class StdioTransport {
             });
         }
         catch (err) {
-            const error = err;
-            await this.sendError(request.id, JSON_RPC_ERRORS.INTERNAL_ERROR, error.message || 'Internal error');
+            // Honor a JSON-RPC `code` carried by the thrown value (McpError or a legacy
+            // plain `{ code, message }` object); otherwise fall back to INTERNAL_ERROR.
+            if (isJsonRpcCodedError(err)) {
+                await this.sendError(request.id, err.code, err.message, err.data);
+            }
+            else {
+                const error = err;
+                await this.sendError(request.id, JSON_RPC_ERRORS.INTERNAL_ERROR, error.message || 'Internal error');
+            }
         }
     }
     async handleNotification(notification) {

package/dist/shared/utils/rabitq.d.ts

@@ -0,0 +1,133 @@
+/**
+ * RaBitQ-style 1-bit sign signatures for fast vector retrieval.
+ *
+ * Ports ruflo's perf-M4 optimization: sign-random-projection + Hamming popcount
+ * as a cheap prefilter ahead of exact cosine reranking.
+ *
+ * ## Why this works
+ *
+ * For unit-normalized embeddings, the sign of each coordinate is a valid
+ * Locality-Sensitive Hash (LSH) for cosine similarity: the probability that two
+ * vectors agree on the sign of a random projection is `1 - theta/pi`, where
+ * `theta` is the angle between them (Charikar 2002, "SimHash"). The AQE
+ * canonical embedding dimension is 384 (patterns.rvf dim=384); the coordinate
+ * basis itself acts as the random projection family, so `bit_i = (vec[i] >= 0)`
+ * yields a Hamming distance that is monotonically related to cosine angle.
+ *
+ * We therefore use Hamming distance over packed 1-bit signatures as a *cheap*
+ * ranking proxy to shrink the candidate pool, then run *exact* cosine on the
+ * survivors. With a large enough rerank pool the final top-k is identical to a
+ * full exact scan — only the work is reduced.
+ *
+ * ## Memory
+ *
+ * A 384-dim Float32 vector costs 1536 bytes. Its sign signature costs 48 bytes
+ * (12 × uint32). That is a 32× index-memory reduction for the prefilter stage.
+ *
+ * Self-contained: no I/O, no side effects, pure functions + one ranking helper.
+ *
+ * @module shared/utils/rabitq
+ */
+/** AQE canonical embedding dimension (patterns.rvf dim=384). */
+export declare const SIGNATURE_DIM = 384;
+/**
+ * Bytes per signature for the canonical 384-dim embedding:
+ * ceil(384 / 32) = 12 words × 4 bytes = 48 bytes.
+ * (vs 384 × 4 = 1536 bytes for the raw Float32 vector → 32× reduction.)
+ */
+export declare const SIGNATURE_BYTES: number;
+/**
+ * Build a 1-bit sign signature from a vector.
+ *
+ * `bit_i = (vec[i] >= 0)`. Bits are packed LSB-first into Uint32 words:
+ * coordinate `i` lives in word `i >> 5` at bit `i & 31`.
+ *
+ * For a 384-dim input this returns 12 words (48 bytes). Inputs of other
+ * dimensions are supported (signature length = ceil(dim / 32) words).
+ *
+ * @param vec Embedding vector (assumed unit-normalized for the LSH guarantee,
+ *            but the function works on any real vector).
+ * @returns Packed sign bits as a Uint32Array.
+ */
+export declare function signSignature(vec: number[] | Float32Array): Uint32Array;
+/**
+ * Hamming distance between two packed signatures: popcount(a XOR b) summed
+ * over all words.
+ *
+ * @throws If the two signatures have different word lengths.
+ */
+export declare function hammingDistance(a: Uint32Array, b: Uint32Array): number;
+/**
+ * Hamming similarity in [0, 1]: `1 - hammingDistance / bits`.
+ *
+ * This is a monotonic proxy for cosine similarity (higher = closer). `bits`
+ * should be the true embedding dimension (e.g. 384), not `words × 32`, so that
+ * trailing padding bits — which are always 0 in both signatures and never
+ * contribute to the distance — don't deflate the normalization.
+ */
+export declare function hammingSimilarity(a: Uint32Array, b: Uint32Array, bits: number): number;
+/** A retrieval candidate. `signature` is optional and lazily built if absent. */
+export interface RaBitQCandidate {
+    id: string;
+    vector: number[] | Float32Array;
+    /** Precomputed sign signature; built on demand from `vector` if omitted. */
+    signature?: Uint32Array;
+}
+/** A scored result. `score` is the exact cosine similarity (or Hamming proxy). */
+export interface RaBitQResult {
+    id: string;
+    score: number;
+}
+/** Tuning knobs for {@link topKBySignature}. */
+export interface TopKOptions {
+    /**
+     * Below this candidate count, skip RaBitQ entirely and do an exact cosine
+     * top-k. RaBitQ's signature-build + Hamming-scan overhead is not worth it for
+     * small N. Default 100 (matches ruflo's gate).
+     */
+    gateN?: number;
+    /**
+     * How many Hamming-ranked candidates to feed into the exact rerank.
+     *
+     * Larger pool → higher recall, more exact-cosine work. **Default is
+     * recall-aware**: `max(4 × k, ceil(0.4 × N))`.
+     *
+     * IMPORTANT — empirically measured tradeoff (384-dim, see
+     * scripts/benchmark-rabitq.ts): a 1-bit sign signature is a *coarse*
+     * quantization, so a small fixed pool (e.g. `4 × k = 40`) does NOT preserve
+     * recall@10 at scale — at N=1000 it captures only ~70-85% of the true top-10,
+     * and worse at N=5000. To keep recall@10 ≥ ~0.95 the pool must be a sizeable
+     * fraction of N (~40% empirically), which limits the achievable speedup.
+     * Callers that can tolerate lower recall may pass a smaller pool for more
+     * speed; callers that need exact output should not use RaBitQ at all.
+     */
+    rerankPool?: number;
+    /**
+     * If true (default), run full cosineSimilarity on the Hamming-top pool and
+     * return the true top-k by cosine. If false, return the Hamming-only ranking
+     * (faster, approximate).
+     */
+    exactRerank?: boolean;
+}
+/**
+ * Retrieve the top-k candidates for a query using a RaBitQ Hamming prefilter
+ * followed by an exact cosine rerank.
+ *
+ * Behavior:
+ * - `candidates.length < gateN` → plain exact cosine top-k (gate; RaBitQ
+ *   overhead not worth it for small N).
+ * - otherwise → build/reuse sign signatures, rank ALL candidates by Hamming
+ *   distance (cheap), take the top `rerankPool`, then:
+ *     - `exactRerank=true` (default): run FULL cosine on just that pool and
+ *       return the true top-k. Output equals an exact scan whenever the true
+ *       top-k all fall within the Hamming top-`rerankPool` — recall is
+ *       preserved by the rerank, only speed changes.
+ *     - `exactRerank=false`: return the Hamming-only top-k (approximate).
+ *
+ * @param query Query vector (same dimension as candidate vectors).
+ * @param candidates Candidate set.
+ * @param k Number of results to return.
+ * @param opts Tuning knobs (see {@link TopKOptions}).
+ */
+export declare function topKBySignature(query: number[] | Float32Array, candidates: RaBitQCandidate[], k: number, opts?: TopKOptions): RaBitQResult[];
+//# sourceMappingURL=rabitq.d.ts.map

package/dist/shared/utils/rabitq.js

@@ -0,0 +1,201 @@
+/**
+ * RaBitQ-style 1-bit sign signatures for fast vector retrieval.
+ *
+ * Ports ruflo's perf-M4 optimization: sign-random-projection + Hamming popcount
+ * as a cheap prefilter ahead of exact cosine reranking.
+ *
+ * ## Why this works
+ *
+ * For unit-normalized embeddings, the sign of each coordinate is a valid
+ * Locality-Sensitive Hash (LSH) for cosine similarity: the probability that two
+ * vectors agree on the sign of a random projection is `1 - theta/pi`, where
+ * `theta` is the angle between them (Charikar 2002, "SimHash"). The AQE
+ * canonical embedding dimension is 384 (patterns.rvf dim=384); the coordinate
+ * basis itself acts as the random projection family, so `bit_i = (vec[i] >= 0)`
+ * yields a Hamming distance that is monotonically related to cosine angle.
+ *
+ * We therefore use Hamming distance over packed 1-bit signatures as a *cheap*
+ * ranking proxy to shrink the candidate pool, then run *exact* cosine on the
+ * survivors. With a large enough rerank pool the final top-k is identical to a
+ * full exact scan — only the work is reduced.
+ *
+ * ## Memory
+ *
+ * A 384-dim Float32 vector costs 1536 bytes. Its sign signature costs 48 bytes
+ * (12 × uint32). That is a 32× index-memory reduction for the prefilter stage.
+ *
+ * Self-contained: no I/O, no side effects, pure functions + one ranking helper.
+ *
+ * @module shared/utils/rabitq
+ */
+import { cosineSimilarity } from './vector-math.js';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Bits packed per Uint32 word. */
+const BITS_PER_WORD = 32;
+/** AQE canonical embedding dimension (patterns.rvf dim=384). */
+export const SIGNATURE_DIM = 384;
+/**
+ * Bytes per signature for the canonical 384-dim embedding:
+ * ceil(384 / 32) = 12 words × 4 bytes = 48 bytes.
+ * (vs 384 × 4 = 1536 bytes for the raw Float32 vector → 32× reduction.)
+ */
+export const SIGNATURE_BYTES = Math.ceil(SIGNATURE_DIM / BITS_PER_WORD) * 4; // 48
+// ============================================================================
+// Popcount (Brian-Kernighan)
+// ============================================================================
+/**
+ * Population count (number of set bits) of a 32-bit word.
+ *
+ * Uses the SWAR (SIMD-within-a-register) bit-twiddle which is branchless and
+ * faster than a per-byte table lookup for 32-bit words. The hdc-fingerprint
+ * module uses a 256-entry per-byte table + Brian-Kernighan for its Uint8Array
+ * vectors; here we operate on Uint32 words, so the SWAR variant is the natural
+ * fit and avoids importing/splitting words into bytes.
+ */
+function popcount32(n) {
+    // Force unsigned 32-bit semantics.
+    n = n >>> 0;
+    n = n - ((n >>> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+    n = (n + (n >>> 4)) & 0x0f0f0f0f;
+    return (Math.imul(n, 0x01010101) >>> 24) & 0xff;
+}
+// ============================================================================
+// Signature construction
+// ============================================================================
+/**
+ * Build a 1-bit sign signature from a vector.
+ *
+ * `bit_i = (vec[i] >= 0)`. Bits are packed LSB-first into Uint32 words:
+ * coordinate `i` lives in word `i >> 5` at bit `i & 31`.
+ *
+ * For a 384-dim input this returns 12 words (48 bytes). Inputs of other
+ * dimensions are supported (signature length = ceil(dim / 32) words).
+ *
+ * @param vec Embedding vector (assumed unit-normalized for the LSH guarantee,
+ *            but the function works on any real vector).
+ * @returns Packed sign bits as a Uint32Array.
+ */
+export function signSignature(vec) {
+    const dim = vec.length;
+    const words = Math.ceil(dim / BITS_PER_WORD);
+    const sig = new Uint32Array(words);
+    for (let i = 0; i < dim; i++) {
+        if (vec[i] >= 0) {
+            sig[i >> 5] |= 1 << (i & 31);
+        }
+    }
+    return sig;
+}
+// ============================================================================
+// Hamming distance / similarity
+// ============================================================================
+/**
+ * Hamming distance between two packed signatures: popcount(a XOR b) summed
+ * over all words.
+ *
+ * @throws If the two signatures have different word lengths.
+ */
+export function hammingDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Signature length mismatch: ${a.length} vs ${b.length} words`);
+    }
+    let dist = 0;
+    for (let i = 0; i < a.length; i++) {
+        dist += popcount32((a[i] ^ b[i]) >>> 0);
+    }
+    return dist;
+}
+/**
+ * Hamming similarity in [0, 1]: `1 - hammingDistance / bits`.
+ *
+ * This is a monotonic proxy for cosine similarity (higher = closer). `bits`
+ * should be the true embedding dimension (e.g. 384), not `words × 32`, so that
+ * trailing padding bits — which are always 0 in both signatures and never
+ * contribute to the distance — don't deflate the normalization.
+ */
+export function hammingSimilarity(a, b, bits) {
+    if (bits <= 0)
+        return 0;
+    return 1 - hammingDistance(a, b) / bits;
+}
+/**
+ * Exact cosine top-k over all candidates. Shared by the small-N gate and the
+ * rerank stage.
+ */
+function exactTopK(query, candidates, k) {
+    const scored = new Array(candidates.length);
+    for (let i = 0; i < candidates.length; i++) {
+        scored[i] = {
+            id: candidates[i].id,
+            score: cosineSimilarity(query, candidates[i].vector),
+        };
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, k);
+}
+/**
+ * Retrieve the top-k candidates for a query using a RaBitQ Hamming prefilter
+ * followed by an exact cosine rerank.
+ *
+ * Behavior:
+ * - `candidates.length < gateN` → plain exact cosine top-k (gate; RaBitQ
+ *   overhead not worth it for small N).
+ * - otherwise → build/reuse sign signatures, rank ALL candidates by Hamming
+ *   distance (cheap), take the top `rerankPool`, then:
+ *     - `exactRerank=true` (default): run FULL cosine on just that pool and
+ *       return the true top-k. Output equals an exact scan whenever the true
+ *       top-k all fall within the Hamming top-`rerankPool` — recall is
+ *       preserved by the rerank, only speed changes.
+ *     - `exactRerank=false`: return the Hamming-only top-k (approximate).
+ *
+ * @param query Query vector (same dimension as candidate vectors).
+ * @param candidates Candidate set.
+ * @param k Number of results to return.
+ * @param opts Tuning knobs (see {@link TopKOptions}).
+ */
+export function topKBySignature(query, candidates, k, opts = {}) {
+    const gateN = opts.gateN ?? 100;
+    const exactRerank = opts.exactRerank ?? true;
+    const n = candidates.length;
+    if (n === 0 || k <= 0)
+        return [];
+    // Recall-aware default pool: a 1-bit signature in high dimensions is coarse,
+    // so the pool must scale with N to keep recall high (see rerankPool docs).
+    const rerankPool = opts.rerankPool ?? Math.max(4 * k, Math.ceil(0.4 * n));
+    // Small-N gate: exact cosine, skip signature machinery entirely.
+    if (n < gateN) {
+        return exactTopK(query, candidates, Math.min(k, n));
+    }
+    const bits = query.length;
+    const querySig = signSignature(query);
+    // Rank ALL candidates by Hamming distance (cheap popcount scan).
+    const hammingRanked = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const cand = candidates[i];
+        const sig = cand.signature ?? signSignature(cand.vector);
+        hammingRanked[i] = { idx: i, dist: hammingDistance(querySig, sig) };
+    }
+    // Ascending distance = descending similarity.
+    hammingRanked.sort((a, b) => a.dist - b.dist);
+    const poolSize = Math.min(rerankPool, n);
+    if (!exactRerank) {
+        // Hamming-only ranking: return the top-k by Hamming proxy similarity.
+        const topK = Math.min(k, n);
+        const out = new Array(topK);
+        for (let i = 0; i < topK; i++) {
+            const { idx, dist } = hammingRanked[i];
+            out[i] = { id: candidates[idx].id, score: 1 - dist / bits };
+        }
+        return out;
+    }
+    // Exact rerank: full cosine over the Hamming-top pool, return true top-k.
+    const pool = new Array(poolSize);
+    for (let i = 0; i < poolSize; i++) {
+        pool[i] = candidates[hammingRanked[i].idx];
+    }
+    return exactTopK(query, pool, Math.min(k, poolSize));
+}
+//# sourceMappingURL=rabitq.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.10.1",
+  "version": "3.10.2",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -68,7 +68,8 @@
     "test:mcp:integration": "npm test -- --run tests/integration/mcp/",
     "test:integration:fast": "NODE_OPTIONS='--max-old-space-size=2048 --expose-gc' vitest run tests/integration/mcp/fleet-init-wires-daemon.test.ts tests/integration/workers/workers-reach-domains.test.ts tests/integration/learning/coordinator-roundtrip.test.ts tests/integration/bridge/bridge-end-to-end.test.ts",
     "test:integration": "NODE_OPTIONS='--max-old-space-size=4096 --expose-gc' vitest run tests/integration/ --exclude='**/browser/**' --exclude='**/browser-integration/**' --exclude='**/*.e2e.test.ts'",
-    "mcp:validate": "echo 'MCP validation: All tools registered in MCP server' && exit 0",
+    "mcp:validate": "node scripts/smoke-mcp-protocol.mjs",
+    "mcp:parity": "node scripts/audit-mcp-tool-parity.mjs",
     "mcp:report": "echo 'MCP Report: uses vitest for test reporting' && exit 0",
     "test:code-intelligence": "npm test -- --run tests/unit/domains/code-intelligence/ tests/unit/coordination/mincut/",
     "verify:counts": "node -e \"const fs=require('fs'),g=require('glob'),p=require('path');const src=g.globSync('src/**/*.ts',{ignore:'src/**/*.test.ts'});const tests=g.globSync('tests/**/*.test.ts');const agents=g.globSync('.claude/agents/v3/qe-*.md');const skills=g.globSync('.claude/skills/**/*.md');const ok=src.length>500&&tests.length>300;const r={status:ok?'pass':'fail',srcFiles:src.length,testFiles:tests.length,agents:agents.length,skills:skills.length};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-counts.json'),JSON.stringify(r,null,2));console.log('Counts:',JSON.stringify(r));if(!ok)process.exit(1)\"",
@@ -85,6 +86,10 @@
     "performance:gate": "npx tsx src/performance/run-gates.ts",
     "test:integration:browser": "VIBIUM_REAL_TESTS=true vitest run tests/integrations/vibium/vibium-real.test.ts",
     "benchmark:token-reduction": "vitest bench tests/benchmarks/code-intelligence-token-reduction.bench.ts",
+    "benchmark:self-learning": "tsx scripts/benchmark-self-learning.ts",
+    "benchmark:rabitq": "tsx scripts/benchmark-rabitq.ts",
+    "plugin:smoke": "bash plugins/agentic-qe-fleet/scripts/smoke.sh",
+    "pretrain:history": "tsx scripts/pretrain-from-history.ts",
     "dev": "node dist/cli/bundle.js",
     "start": "node dist/cli/bundle.js",
     "typecheck": "tsc --noEmit",
@@ -256,6 +261,7 @@
     ".claude/skills",
     ".claude/commands",
     ".claude/helpers",
+    ".claude/hooks",
     ".opencode/agents",
     ".opencode/skills",
     ".opencode/tools",

package/dist/cli/chunks/adapter-3JS2CN7C.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.10.1");process.exit(0)}
-import{a,b,c}from"./chunk-32R7EA7B.js";import"./chunk-GTRXZJNX.js";import"./chunk-BN7ERYXI.js";import"./chunk-QNW335PD.js";import"./chunk-2TDWCXZ6.js";import"./chunk-4AWJ5PE4.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-Q4GFNGU6.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.10.1");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-BECU52UY.js";import"./chunk-G3BQU3Q6.js";import"./chunk-6VQ5MFJ6.js";import"./chunk-TFNLXAK5.js";import"./chunk-ECPB7IAH.js";import"./chunk-LF7URN2X.js";import"./chunk-UDFLR7GR.js";import"./chunk-WS4XVJHI.js";import"./chunk-NRLT44YB.js";import"./chunk-YPOTBXPU.js";import"./chunk-AUVC3DDB.js";import"./chunk-NPSBMDVU.js";import"./chunk-F3OVFA6W.js";import"./chunk-PXFQSVA2.js";import"./chunk-Q24OJX44.js";import"./chunk-GXJ4BCGC.js";import"./chunk-QNW335PD.js";import"./chunk-P7T5Y735.js";import"./chunk-VPCE5CIT.js";import"./chunk-BGBSYF3K.js";import"./chunk-Y2DPXMOR.js";import"./chunk-2TDWCXZ6.js";import"./chunk-IK6AJX3C.js";import"./chunk-XRK7FBTY.js";import"./chunk-PLRSKAFZ.js";import"./chunk-GRG3OP34.js";import"./chunk-XKOKMS5A.js";import"./chunk-2ETDES5W.js";import"./chunk-MVGVD6LS.js";import"./chunk-25QGPRWN.js";import"./chunk-KRXKU54J.js";import"./chunk-ELZ67OHQ.js";import"./chunk-4AWJ5PE4.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-Q3MAL22Y.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.10.1");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j}from"./chunk-BF7MUYWC.js";import"./chunk-EIROAH6N.js";import"./chunk-Q24OJX44.js";import"./chunk-GXJ4BCGC.js";import"./chunk-QNW335PD.js";import"./chunk-VPCE5CIT.js";import"./chunk-BGBSYF3K.js";import"./chunk-2TDWCXZ6.js";import"./chunk-IK6AJX3C.js";import"./chunk-XRK7FBTY.js";import"./chunk-PLRSKAFZ.js";import"./chunk-GRG3OP34.js";import"./chunk-XKOKMS5A.js";import"./chunk-2ETDES5W.js";import"./chunk-MVGVD6LS.js";import"./chunk-25QGPRWN.js";import"./chunk-KRXKU54J.js";import"./chunk-ELZ67OHQ.js";import"./chunk-4AWJ5PE4.js";export{j as MCPToolBase,i as defaultToolLogger,h as getLLMRouter,d as getMemoryBackend,f as getSharedLLMRouter,b as getSharedMemoryBackend,a as registerRvfResetFn,g as resetSharedLLMRouter,c as resetSharedMemoryBackend,e as setSharedLLMRouter};

package/dist/cli/chunks/browser-workflow-JX3M2UWG.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.10.1");process.exit(0)}
-import{a}from"./chunk-6D57DWQ6.js";import"./chunk-BF7MUYWC.js";import"./chunk-EIROAH6N.js";import"./chunk-Q24OJX44.js";import"./chunk-GXJ4BCGC.js";import"./chunk-QNW335PD.js";import"./chunk-VPCE5CIT.js";import"./chunk-BGBSYF3K.js";import"./chunk-2TDWCXZ6.js";import"./chunk-IK6AJX3C.js";import"./chunk-XRK7FBTY.js";import"./chunk-PLRSKAFZ.js";import"./chunk-GRG3OP34.js";import"./chunk-XKOKMS5A.js";import"./chunk-2ETDES5W.js";import"./chunk-MVGVD6LS.js";import"./chunk-25QGPRWN.js";import"./chunk-KRXKU54J.js";import"./chunk-ELZ67OHQ.js";import"./chunk-4AWJ5PE4.js";export{a as BrowserWorkflowTool};