agentic-qe 3.14.6 → 3.14.8

package/dist/mcp/tools/test-generation/generate.d.ts

@@ -8,7 +8,9 @@
  */
 import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base';
 import { ToolResult } from '../../types';
+import { GenerateTestsRequest } from '../../../domains/test-generation/interfaces';
 export interface TestGenerateParams {
+    behaviorExamples?: GenerateTestsRequest['behaviorExamples'];
     sourceFiles: string[];
     testType?: 'unit' | 'integration' | 'e2e';
     framework?: 'jest' | 'vitest' | 'mocha' | 'pytest' | 'node-test';
@@ -21,7 +23,8 @@ export interface TestGenerateParams {
 }
 export interface TestGenerateResult {
     tests: GeneratedTest[];
-    coverageEstimate: number;
+    /** null means unmeasured; never coerce unknown coverage to measured zero. */
+    coverageEstimate: number | null;
     patternsUsed: string[];
     suggestions: string[];
     antiPatterns?: AntiPattern[];
@@ -34,6 +37,8 @@ export interface GeneratedTest {
     testCode: string;
     type: 'unit' | 'integration' | 'e2e';
     assertions: number;
+    generationMode?: string;
+    generationLimits?: string[];
 }
 export interface AntiPattern {
     name: string;

package/dist/mcp/tools/test-generation/generate.js

@@ -10,6 +10,7 @@ import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base.js';
 import { createTestGeneratorServiceWithDependencies } from '../../../domains/test-generation/services/test-generator.js';
 import { TokenOptimizerService } from '../../../optimization/token-optimizer-service.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { BEHAVIOR_EXAMPLE_ITEM_SCHEMA, validateBehaviorExamples } from '../../../domains/test-generation/services/behavior-example-validation.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -45,6 +46,9 @@ export class TestGenerateTool extends MCPToolBase {
     async execute(params, context) {
         const { sourceFiles, testType = 'unit', framework = 'vitest', language = 'typescript', coverageTarget = 80, patterns = [], aiEnhancement = true, detectAntiPatterns = false, } = params;
         try {
+            // #795: reject malformed caller fixtures at the tool boundary, before
+            // any service or domain work runs.
+            const behaviorExamples = validateBehaviorExamples(params.behaviorExamples);
             // Stream progress updates
             this.emitStream(context, {
                 status: 'analyzing',
@@ -79,6 +83,7 @@ export class TestGenerateTool extends MCPToolBase {
             const service = await this.getService(context);
             // Build the domain request from MCP params
             const domainRequest = {
+                behaviorExamples,
                 sourceFiles,
                 testType: testType,
                 framework: framework,
@@ -103,6 +108,8 @@ export class TestGenerateTool extends MCPToolBase {
                 testCode: test.testCode,
                 type: test.type,
                 assertions: test.assertions,
+                generationMode: test.generationMode,
+                generationLimits: test.generationLimits,
             }));
             this.emitStream(context, {
                 status: 'generating',
@@ -150,6 +157,7 @@ export class TestGenerateTool extends MCPToolBase {
 const TEST_GENERATE_SCHEMA = {
     type: 'object',
     properties: {
+        behaviorExamples: { type: 'array', description: 'Trusted JSON specification fixtures: functionName, args, expected', items: BEHAVIOR_EXAMPLE_ITEM_SCHEMA },
         sourceFiles: {
             type: 'array',
             description: 'Array of source file paths to generate tests for',

package/dist/mcp/types.d.ts

@@ -14,6 +14,8 @@ export interface ToolParameter {
     required?: boolean;
     default?: unknown;
     enum?: string[];
+    /** JSON Schema for array elements (only meaningful when type is 'array'). */
+    items?: Record<string, unknown>;
 }
 /**
  * Optional safety metadata advertised by an MCP tool.
@@ -40,6 +42,8 @@ export interface ToolDefinition {
     domain?: DomainName;
     lazyLoad?: boolean;
     isConcurrencySafe?: boolean;
+    /** False for live reads whose results must not be reused by the session cache. */
+    isCacheable?: boolean;
     annotations?: ToolAnnotations;
 }
 /**
@@ -171,6 +175,7 @@ export interface TestGenerateParams {
     framework?: string;
     testType?: 'unit' | 'integration' | 'e2e' | 'property-based';
     coverageGoal?: number;
+    behaviorExamples?: import('../domains/test-generation/interfaces').BehaviorExample[];
     aiEnhancement?: boolean;
     detectAntiPatterns?: boolean;
 }
@@ -467,14 +472,15 @@ export interface TestGenerateResult {
     status: string;
     duration: number;
     testsGenerated: number;
-    coverageEstimate: number;
+    /** null means unmeasured; never coerce unknown coverage to measured zero. */
+    coverageEstimate: number | null;
     antiPatternsDetected?: number;
     suggestions?: string[];
     savedFiles?: string[];
     patternsUsed?: string[];
     /**
      * #567: true when the ADR-051 LLM branch actually ran. When false the tests
-     * are deterministic template scaffolding — see `generationMode`/`note`.
+     * come from deterministic fixtures or scaffolding — see `generationMode`/`note`.
      */
     llmEnhanced?: boolean;
     /** #567: set to 'deterministic-template' when no LLM enhancement was applied. */

package/dist/optimization/session-cache.js

@@ -40,17 +40,19 @@ export const DEFAULT_SESSION_CACHE_CONFIG = {
  * Ensures identical logical objects always produce the same fingerprint.
  */
 function canonicalStringify(value) {
-    if (value === null || value === undefined)
-        return JSON.stringify(value);
-    if (typeof value !== 'object')
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return '[' + value.map(v => canonicalStringify(v)).join(',') + ']';
+    // Honor JSON's array holes, undefined fields and toJSON (for example Date)
+    // before ordering keys. Hand-built fragments can conflate distinct inputs.
+    const normalized = JSON.parse(JSON.stringify(value));
+    function encode(item) {
+        if (item === null || typeof item !== 'object')
+            return JSON.stringify(item);
+        if (Array.isArray(item))
+            return '[' + item.map(encode).join(',') + ']';
+        const obj = item;
+        return '{' + Object.keys(obj).sort()
+            .map(key => JSON.stringify(key) + ':' + encode(obj[key])).join(',') + '}';
     }
-    const obj = value;
-    const sortedKeys = Object.keys(obj).sort();
-    const pairs = sortedKeys.map(k => JSON.stringify(k) + ':' + canonicalStringify(obj[k]));
-    return '{' + pairs.join(',') + '}';
+    return encode(normalized);
 }
 // ============================================================================
 // Implementation
@@ -114,7 +116,7 @@ export class SessionOperationCache {
         if (!this.config.enabled)
             return;
         // Evict oldest if at capacity
-        if (this.cache.size >= this.config.maxEntries) {
+        if (!this.cache.has(fingerprint) && this.cache.size >= this.config.maxEntries) {
             this.evictOldest();
         }
         const entry = {

package/dist/plugins/cache.js

@@ -51,9 +51,16 @@ export class PluginCache {
         }
         // Copy source to cache
         fs.mkdirSync(dir, { recursive: true });
-        this.copyDir(sourceDir, dir);
-        // Write the manifest (ensure it's present even if source didn't have it at root)
-        fs.writeFileSync(path.join(dir, 'qe-plugin.json'), JSON.stringify(manifest, null, 2));
+        try {
+            this.copyDir(sourceDir, dir);
+            // Write the manifest (ensure it's present even if source didn't have it at root)
+            fs.writeFileSync(path.join(dir, 'qe-plugin.json'), JSON.stringify(manifest, null, 2));
+        }
+        catch (error) {
+            // A partial directory must not satisfy the immutable-cache fast path on retry.
+            fs.rmSync(dir, { recursive: true, force: true });
+            throw error;
+        }
         // Cleanup old versions
         this.pruneOldVersions(manifest.name);
         return dir;

package/dist/shared/embeddings/embedding-cache.js

@@ -36,7 +36,7 @@ export class EmbeddingCache {
             // Move to end (LRU update)
             this.cache.delete(key);
             this.cache.set(key, entry);
-            return entry.embedding;
+            return [...entry.embedding];
         }
         this.misses++;
         return null;
@@ -54,7 +54,7 @@ export class EmbeddingCache {
             }
         }
         const entry = {
-            embedding,
+            embedding: [...embedding],
             timestamp: Date.now(),
             model,
         };
@@ -118,7 +118,7 @@ export class EmbeddingCache {
     export() {
         return Array.from(this.cache.entries()).map(([key, entry]) => ({
             key,
-            entry,
+            entry: { ...entry, embedding: [...entry.embedding] },
         }));
     }
     /**
@@ -128,7 +128,7 @@ export class EmbeddingCache {
         this.cache.clear();
         for (const { key, entry } of data) {
             if (this.cache.size < this.maxSize) {
-                this.cache.set(key, entry);
+                this.cache.set(key, { ...entry, embedding: [...entry.embedding] });
             }
         }
     }

package/dist/shared/error-utils.d.ts

@@ -13,4 +13,19 @@ export declare function toErrorMessage(error: unknown): string;
  * Coerce unknown error value to an Error instance.
  */
 export declare function toError(error: unknown): Error;
+/**
+ * A request was rejected because the caller's input is invalid (a malformed
+ * argument, an unknown function name, an unsupported option combination).
+ *
+ * The failure is deterministic and says nothing about the health of the
+ * component that rejected it, so it must not be retried and must not count
+ * toward a domain circuit breaker (ADR-064). The marker survives being
+ * flattened to a message string via `callerError` on TaskFailed events.
+ */
+export declare class CallerInputError extends Error {
+    readonly callerError: true;
+    constructor(message: string);
+}
+/** True when `error` is (or is marked as) a caller-input error. */
+export declare function isCallerInputError(error: unknown): boolean;
 //# sourceMappingURL=error-utils.d.ts.map

package/dist/shared/error-utils.js

@@ -17,4 +17,25 @@ export function toErrorMessage(error) {
 export function toError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
+/**
+ * A request was rejected because the caller's input is invalid (a malformed
+ * argument, an unknown function name, an unsupported option combination).
+ *
+ * The failure is deterministic and says nothing about the health of the
+ * component that rejected it, so it must not be retried and must not count
+ * toward a domain circuit breaker (ADR-064). The marker survives being
+ * flattened to a message string via `callerError` on TaskFailed events.
+ */
+export class CallerInputError extends Error {
+    callerError = true;
+    constructor(message) {
+        super(message);
+        this.name = 'CallerInputError';
+    }
+}
+/** True when `error` is (or is marked as) a caller-input error. */
+export function isCallerInputError(error) {
+    return error instanceof CallerInputError
+        || (typeof error === 'object' && error !== null && error.callerError === true);
+}
 //# sourceMappingURL=error-utils.js.map

package/dist/shared/events/domain-events.d.ts

@@ -17,7 +17,8 @@ export interface TestSuiteCreatedPayload {
     suiteId: string;
     testCount: number;
     sourceFiles: string[];
-    coverageEstimate: number;
+    /** null means unmeasured; never coerce unknown coverage to measured zero. */
+    coverageEstimate: number | null;
 }
 export declare const TestGenerationEvents: {
     readonly TestGenerated: "test-generation.TestGenerated";

package/dist/shared/llm/cache.js

@@ -5,6 +5,7 @@
  * Provides efficient caching of LLM responses to reduce costs and latency
  * for repeated queries. Uses LRU (Least Recently Used) eviction policy.
  */
+import { createHash } from 'node:crypto';
 /**
  * Default cache configuration
  */
@@ -41,15 +42,9 @@ export class LLMCache {
             options?.systemPrompt ?? '',
             input,
         ];
-        // Simple hash function
-        const str = parts.join('|');
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash;
-        }
-        return `${type}:${Math.abs(hash).toString(36)}`;
+        // Encode field boundaries before hashing: prompt text may contain delimiters.
+        const hash = createHash('sha256').update(JSON.stringify(parts)).digest('hex');
+        return `${type}:${hash}`;
     }
     /**
      * Get a cached value
@@ -182,7 +177,9 @@ export class LLMCache {
             entry.createdAt = new Date(entry.createdAt);
             entry.lastAccessedAt = new Date(entry.lastAccessedAt);
             this.cache.set(key, entry);
-            this.accessOrder.push(key);
+            if (this.config.enableLRU) {
+                this.updateAccessOrder(key);
+            }
         }
         // Evict if over capacity
         while (this.cache.size > this.config.maxSize) {

package/dist/shared/retry-engine.js

@@ -142,6 +142,10 @@ function delay(ms, signal) {
  * promise rejects with an `AbortError`.
  */
 export async function withRetry(fn, options) {
+    // Disabling retries must not bypass the caller's cancellation boundary.
+    if (options?.abortSignal?.aborted) {
+        throw options.abortSignal.reason ?? new DOMException('The operation was aborted.', 'AbortError');
+    }
     // Kill switch: bypass retry entirely when disabled
     if (process.env.AQE_RETRY_DISABLED === 'true') {
         const result = await fn();

package/dist/shared/test-runner-process.d.ts

@@ -0,0 +1,10 @@
+import { type ChildProcess } from 'node:child_process';
+/** Keep detached runners subject to the CLI's synchronous exit handling. */
+export declare function trackTestRunnerExit(proc: ChildProcess): () => void;
+/**
+ * Stop a test runner spawned in its own POSIX process group. The returned
+ * promise waits for the group to stop before report files may be removed.
+ * Windows uses taskkill's tree operation while the root PID still exists.
+ */
+export declare function terminateTestRunner(proc: ChildProcess): Promise<void>;
+//# sourceMappingURL=test-runner-process.d.ts.map

package/dist/shared/test-runner-process.js

@@ -0,0 +1,210 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { readdirSync, readFileSync } from 'node:fs';
+/** Linux signal 0 also sees zombies, which can never execute or write files. */
+function hasLiveLinuxGroupMember(group) {
+    for (const pid of readdirSync('/proc')) {
+        if (!/^\d+$/.test(pid))
+            continue;
+        let stat;
+        try {
+            stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        }
+        catch (error) {
+            if (['ENOENT', 'ESRCH'].includes(error.code ?? ''))
+                continue;
+            throw error; // Unknown process state must not be claimed as stopped.
+        }
+        // The comm field can contain spaces and parentheses; its final ')' is the
+        // boundary before state, ppid and pgrp, not the first whitespace token.
+        const fields = stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/);
+        if (fields.length < 3 || !/^\d+$/.test(fields[2]))
+            throw new Error(`Invalid process stat for ${pid}`);
+        if (Number(fields[2]) === group && fields[0] !== 'Z' && fields[0] !== 'X')
+            return true;
+    }
+    return false;
+}
+/** Signal probes on Darwin may deny access while dead group members are reaped. */
+function hasLiveDarwinGroupMember(group) {
+    const snapshot = execFileSync('ps', ['-axo', 'pgid=,stat='], {
+        encoding: 'utf8', timeout: 1000, maxBuffer: 1024 * 1024,
+    });
+    for (const line of snapshot.split('\n')) {
+        if (!line.trim())
+            continue;
+        const match = /^\s*(\d+)\s+([A-Z?])\S*\s*$/.exec(line);
+        if (!match)
+            throw new Error('Could not determine Darwin process group state');
+        if (Number(match[1]) === group && match[2] !== 'Z')
+            return true;
+    }
+    return false;
+}
+const activeGroups = new Set();
+const stopGroupsOnExit = () => {
+    for (const pid of activeGroups) {
+        try {
+            process.kill(-pid, 'SIGKILL');
+        }
+        catch { /* Already exited. */ }
+    }
+};
+/** Keep detached runners subject to the CLI's synchronous exit handling. */
+export function trackTestRunnerExit(proc) {
+    const pid = proc.pid;
+    if (process.platform === 'win32' || pid === undefined)
+        return () => { };
+    if (activeGroups.size === 0)
+        process.once('exit', stopGroupsOnExit);
+    activeGroups.add(pid);
+    return () => {
+        activeGroups.delete(pid);
+        if (activeGroups.size === 0)
+            process.off('exit', stopGroupsOnExit);
+    };
+}
+/**
+ * Stop a test runner spawned in its own POSIX process group. The returned
+ * promise waits for the group to stop before report files may be removed.
+ * Windows uses taskkill's tree operation while the root PID still exists.
+ */
+export function terminateTestRunner(proc) {
+    return new Promise((resolve, reject) => {
+        const platform = process.platform;
+        const linux = platform === 'linux';
+        const grouped = process.platform !== 'win32' && proc.pid !== undefined;
+        const windowsTree = process.platform === 'win32' && proc.pid !== undefined;
+        let timer;
+        let finished = false;
+        let forceSent = false;
+        let closed = false;
+        let treeStopped = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            proc.off('close', onClose);
+            resolve();
+        };
+        const fail = (error) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            proc.off('close', onClose);
+            reject(error);
+        };
+        const groupExists = () => {
+            try {
+                process.kill(-proc.pid, 0);
+                return forceSent && linux ? hasLiveLinuxGroupMember(proc.pid) : true;
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    return false;
+                // A delivered group signal is not proof every member died. Inspect
+                // actual states; failures/malformed snapshots remain unknown and reject.
+                if (platform === 'darwin' && error.code === 'EPERM') {
+                    return hasLiveDarwinGroupMember(proc.pid);
+                }
+                if (forceSent && linux && error.code === 'EPERM') {
+                    return hasLiveLinuxGroupMember(proc.pid);
+                }
+                throw error;
+            }
+        };
+        const signalGroup = (signal) => {
+            try {
+                process.kill(-proc.pid, signal);
+                return true;
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    return false;
+                throw error;
+            }
+        };
+        const onClose = () => {
+            closed = true;
+            try {
+                if (windowsTree) {
+                    if (treeStopped)
+                        finish();
+                    return;
+                }
+                // A root can exit before a TERM-resistant descendant. Keep escalation
+                // active while its owned group exists, even when stdio has closed.
+                if (!grouped || !groupExists())
+                    finish();
+            }
+            catch (error) {
+                fail(error);
+            }
+        };
+        proc.once('close', onClose);
+        try {
+            if (grouped) {
+                if (!signalGroup('SIGTERM')) {
+                    finish();
+                    return;
+                }
+                timer = setTimeout(() => {
+                    try {
+                        if (!signalGroup('SIGKILL')) {
+                            finish();
+                            return;
+                        }
+                        forceSent = true;
+                        const deadline = Date.now() + 1000;
+                        const poll = () => {
+                            try {
+                                // Do not discard report files while group exit is unknown.
+                                if (!groupExists())
+                                    finish();
+                                else if (Date.now() >= deadline)
+                                    fail(new Error(`Test runner group ${proc.pid} survived SIGKILL.`));
+                                else
+                                    timer = setTimeout(poll, 20);
+                            }
+                            catch (error) {
+                                fail(error);
+                            }
+                        };
+                        poll();
+                    }
+                    catch (error) {
+                        fail(error);
+                    }
+                }, 1000);
+            }
+            else if (windowsTree) {
+                const killer = spawn('taskkill', ['/PID', String(proc.pid), '/T', '/F'], {
+                    stdio: 'ignore', windowsHide: true, timeout: 2000,
+                });
+                killer.once('error', fail);
+                killer.once('close', code => {
+                    if (code !== 0) {
+                        fail(new Error(`Test runner tree termination failed (taskkill exit ${code}).`));
+                    }
+                    else {
+                        treeStopped = true;
+                        if (closed)
+                            finish();
+                    }
+                });
+            }
+            else {
+                // No PID is available before spawn failure (and in test doubles).
+                proc.kill('SIGTERM');
+                if (finished)
+                    return;
+                timer = setTimeout(() => { proc.kill('SIGKILL'); }, 1000);
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+}
+//# sourceMappingURL=test-runner-process.js.map

package/dist/validation/quality-verdict.js

@@ -37,11 +37,12 @@ export async function computeQualityVerdict(input) {
         throw new Error('RequirementChecklist must have a non-empty, constant denominator (ADR-117).');
     }
     // 1. Mechanical gate (ADR-113). Non-execution ⇒ fail, no judge consulted.
-    const mechanicalPass = input.oracle != null && input.oracle.baselinePassed && input.oracle.passed;
+    const mechanicalPass = input.oracle != null
+        && input.oracle.baselinePassed === true && input.oracle.passed === true;
     if (!mechanicalPass) {
         const why = input.oracle == null
             ? 'oracle did not run'
-            : !input.oracle.baselinePassed
+            : input.oracle.baselinePassed !== true
                 ? 'tests did not execute against the reference implementation'
                 : 'mutation score below threshold';
         return {

package/dist/workers/quality-daemon/priority-queue.js

@@ -30,7 +30,10 @@ export class PriorityQueue {
      */
     enqueue(item) {
         if (this.size >= this._maxSize) {
-            return false;
+            // Stale background tasks must not consume capacity needed by new alerts.
+            this.pruneExpired();
+            if (this.size >= this._maxSize)
+                return false;
         }
         this.queues[item.priority].push(item);
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.14.6",
+  "version": "3.14.8",
   "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",
@@ -78,7 +78,7 @@
     "mcp": "tsx src/mcp/entry.ts",
     "test": "NODE_OPTIONS='--max-old-space-size=1024 --expose-gc' vitest run",
     "test:unit": "npm run test:unit:fast && npm run test:unit:heavy && npm run test:unit:mcp",
-    "test:unit:fast": "vitest run --exclude='**/qe-reasoning-bank.test.ts' --exclude='**/qe-reasoning-bank-feedback-loop.test.ts' --exclude='**/aqe-learning-engine.test.ts' --exclude='**/aqe-learning-engine-patterns.test.ts' tests/unit/adapters tests/unit/shared tests/unit/cli tests/unit/learning tests/unit/kernel tests/unit/workers tests/unit/routing tests/unit/strange-loop tests/unit/sync tests/unit/feedback tests/unit/error-paths tests/unit/early-exit tests/unit/causal-discovery tests/unit/neural-optimizer tests/unit/test-scheduling tests/unit/logging tests/unit/validation tests/unit/memory tests/unit/performance tests/unit/scripts tests/unit/planning tests/context",
+    "test:unit:fast": "vitest run --exclude='**/qe-reasoning-bank.test.ts' --exclude='**/aqe-learning-engine.test.ts' --exclude='**/aqe-learning-engine-patterns.test.ts' tests/unit/adapters tests/unit/shared tests/unit/cli tests/unit/learning tests/unit/kernel tests/unit/workers tests/unit/routing tests/unit/strange-loop tests/unit/sync tests/unit/feedback tests/unit/error-paths tests/unit/early-exit tests/unit/causal-discovery tests/unit/neural-optimizer tests/unit/test-scheduling tests/unit/logging tests/unit/validation tests/unit/memory tests/unit/performance tests/unit/scripts tests/unit/planning tests/context",
     "test:unit:heavy": "vitest run tests/unit/coordination tests/unit/domains tests/unit/integrations tests/unit/optimization tests/unit/init --exclude='**/browser/**' --exclude='**/*.e2e.test.ts' --exclude='**/vibium/**' --exclude='**/browser-swarm-coordinator.test.ts'",
     "test:unit:mcp": "vitest run tests/unit/mcp --exclude='**/mcp/handlers/domain-handlers.test.ts' --fileParallelism=false",
     "test:ci": "vitest run --exclude='**/browser/**' --exclude='**/*.e2e.test.ts' --exclude='**/vibium/**' --exclude='**/integration/browser/**' --exclude='**/browser-swarm-coordinator.test.ts' --exclude='**/mcp/handlers/domain-handlers.test.ts' --exclude='**/fixtures/init-corpus/**'",
@@ -115,7 +115,7 @@
     "test:journeys:ci": "vitest run tests/integration/ --exclude='**/browser/**' --exclude='**/browser-integration/**' --exclude='**/integration/mcp/**' --exclude='**/integration/sync/**' --exclude='**/integration/learning/**' --exclude='**/integration/domains/**' --exclude='**/integration/llm/**' --exclude='**/integration/n8n/**' --exclude='**/*.e2e.test.ts'",
     "test:watch": "vitest",
     "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",
+    "test:integration:browser": "VIBIUM_REAL_TESTS=true vitest run --config config/vitest.browser.config.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",
@@ -186,7 +186,6 @@
     "chalk": "^5.6.2",
     "cli-progress": "^3.12.0",
     "commander": "^14.0.3",
-    "fast-glob": "^3.3.3",
     "fast-json-patch": "^3.1.1",
     "jose": "^6.1.3",
     "ora": "^9.0.0",
@@ -194,15 +193,16 @@
     "prime-radiant-advanced-wasm": "^0.1.3",
     "secure-json-parse": "^4.1.0",
     "semver": "^7.8.5",
+    "tinyglobby": "^0.2.17",
     "typescript": "^5.9.3",
     "uuid": "^14.0.0",
-    "vibium": "^0.1.2",
     "web-tree-sitter": "~0.26.8",
     "yaml": "^2.8.2"
   },
   "peerDependencies": {
     "@claude-flow/browser": "3.0.0-alpha.1",
-    "@claude-flow/guidance": "3.0.0-alpha.1"
+    "@claude-flow/guidance": "3.0.0-alpha.1",
+    "vibium": "^26.8.21"
   },
   "peerDependenciesMeta": {
     "@claude-flow/browser": {
@@ -210,6 +210,9 @@
     },
     "@claude-flow/guidance": {
       "optional": true
+    },
+    "vibium": {
+      "optional": true
     }
   },
   "optionalDependencies": {
@@ -276,6 +279,7 @@
     "glob": "^13.0.0",
     "msw": "^2.12.7",
     "tsx": "^4.21.0",
+    "vibium": "^26.8.21",
     "vitest": "^5.0.1"
   },
   "engines": {

package/dist/cli/chunks/adapter-UYOJPTOX.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.14.6");process.exit(0)}
-import{a,b,c}from"./chunk-RFNPJK6N.js";import"./chunk-YSLL6VSL.js";import"./chunk-2YXGBZWV.js";import"./chunk-AIRGNL55.js";import"./chunk-MJS53PRX.js";import"./chunk-64VGZQLB.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-JR5AVQXR.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.14.6");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-AHKELLIO.js";import"./chunk-CM7U6TAX.js";import"./chunk-MBRHSU6W.js";import"./chunk-Z6GGIRQQ.js";import"./chunk-CD542DNJ.js";import"./chunk-7LPR6HJG.js";import"./chunk-7D3V65N5.js";import"./chunk-CCK4BF76.js";import"./chunk-YFBSPLJG.js";import"./chunk-7CUQCCMD.js";import"./chunk-3HZS4M3O.js";import"./chunk-Y3LZ35OG.js";import"./chunk-JVNTSNWU.js";import"./chunk-SMDN3BQZ.js";import"./chunk-6U7LNMWZ.js";import"./chunk-I33ERSGB.js";import"./chunk-IG5GNEC6.js";import"./chunk-UNFFDHER.js";import"./chunk-2TMWAQQ3.js";import"./chunk-2JVWITNK.js";import"./chunk-Q5XTSMWR.js";import"./chunk-AIRGNL55.js";import"./chunk-QW6VMTBR.js";import"./chunk-SDRHUMJB.js";import"./chunk-5J6W7SIA.js";import"./chunk-KNNISEDY.js";import"./chunk-TCHGOB2N.js";import"./chunk-FBMN7B46.js";import"./chunk-ENGZ4D5V.js";import"./chunk-MJS53PRX.js";import"./chunk-DPYSUDAO.js";import"./chunk-PI7TJS62.js";import"./chunk-EAY2JMZG.js";import"./chunk-C6KWXUFJ.js";import"./chunk-IB27QACC.js";import"./chunk-6SH5VZUD.js";import"./chunk-SESK3ARK.js";import"./chunk-SNOBH4AZ.js";import"./chunk-IQO7UCFR.js";import"./chunk-DUYOVM5I.js";import"./chunk-64VGZQLB.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};