agentic-qe 3.14.6 → 3.14.8

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

@@ -200,12 +200,13 @@ export async function runCodeIntelligenceScan(projectPath) {
             namespace: 'code-intelligence:kg',
             enableVectorEmbeddings: true,
         });
-        const glob = await import('fast-glob');
-        const files = await glob.default([
+        const { glob } = await import('tinyglobby');
+        const files = await glob([
             '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
         ], {
             cwd: projectPath,
             ignore: ['node_modules/**', 'dist/**', 'coverage/**', '.agentic-qe/**'],
+            expandDirectories: false,
         });
         const result = await kgService.index({
             paths: files.map(f => join(projectPath, f)),

package/dist/init/init-wizard.d.ts

@@ -16,6 +16,8 @@ export interface InitOrchestratorOptions {
     autoMode?: boolean;
     /** Skip pattern loading */
     skipPatterns?: boolean;
+    /** Explicitly install the optional browser engine and browser payload. */
+    browserEngine?: boolean;
     /** Minimal configuration */
     minimal?: boolean;
     /** Pre-trained patterns library */

package/dist/init/orchestrator.js

@@ -33,6 +33,7 @@ export class ModularInitOrchestrator {
                 skipPatterns: options.skipPatterns,
                 skipCodeIndex: options.skipCodeIndex,
                 minimal: options.minimal,
+                browserEngine: options.browserEngine,
                 withN8n: options.withN8n,
                 withOpenCode: options.withOpenCode,
                 withKiro: options.withKiro,

package/dist/init/phases/06-code-intelligence.js

@@ -230,12 +230,13 @@ export class CodeIntelligencePhase extends BasePhase {
                 filesToIndex = changedFiles;
             }
             else {
-                const glob = await import('fast-glob');
-                const files = await glob.default([
+                const { glob } = await import('tinyglobby');
+                const files = await glob([
                     '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
                 ], {
                     cwd: projectRoot,
                     ignore: SCAN_IGNORE_PATTERNS,
+                    expandDirectories: false,
                 });
                 filesToIndex = files.map(f => join(projectRoot, f));
             }
@@ -439,12 +440,13 @@ export class CodeIntelligencePhase extends BasePhase {
      * Find files modified since the given date
      */
     async findChangedFiles(projectRoot, since) {
-        const glob = await import('fast-glob');
-        const files = await glob.default([
+        const { glob } = await import('tinyglobby');
+        const files = await glob([
             '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
         ], {
             cwd: projectRoot,
             ignore: SCAN_IGNORE_PATTERNS,
+            expandDirectories: false,
         });
         const sinceMs = since.getTime();
         const changed = [];

package/dist/init/phases/09-assets.js

@@ -79,19 +79,9 @@ export class AssetsPhase extends BasePhase {
             // Initialize overlay configs in agent registry for runtime use
             initializeOverlays(projectRoot);
         }
-        // Install Vibium browser engine for the qe-browser fleet skill.
-        // Graceful — never fails init if Vibium cannot be installed.
-        // Skipped in --minimal mode per ADR-086 minimal-footprint guidance.
-        //
-        // H6 (devil's-advocate finding): the install can take up to 3 minutes
-        // on cold caches because npm downloads Vibium AND lazily downloads a
-        // Chrome for Testing binary. spawnSync blocks the event loop, so the
-        // user sees no output for the entire duration. We log a clear pre-spawn
-        // message so users don't Ctrl-C thinking init hung. Future work: move
-        // this to a lazy/on-first-use install path so non-browser users never
-        // pay the cost.
+        // Browser setup is explicitly requested; normal init never downloads a browser.
         let browserEngine;
-        if (!options.minimal) {
+        if (options.browserEngine === true && !options.minimal) {
             try {
                 // Pre-flight check: if vibium is already on PATH, skip the loud
                 // banner so we don't scare users on the common path.
@@ -108,7 +98,7 @@ export class AssetsPhase extends BasePhase {
                 else {
                     // Not installed → we're about to spawn `npm install -g vibium`
                     // which can take 1–3 minutes on a cold cache. Tell the user.
-                    context.services.log('  Browser engine: installing vibium via npm (this can take 1–3 minutes on first run; downloads Chrome for Testing lazily)…');
+                    context.services.log('  Browser engine: installing vibium via npm (this can take 1–3 minutes on first run; downloads Chrome for Testing)…');
                     browserEngine = installBrowserEngine({ skip: false });
                     switch (browserEngine.status) {
                         case 'installed':
@@ -118,10 +108,10 @@ export class AssetsPhase extends BasePhase {
                             context.services.log('  Browser engine: skipped');
                             break;
                         case 'install-failed':
-                            context.services.warn(`Browser engine install failed (qe-browser skill will be unavailable until you run \`npm install -g vibium\`): ${browserEngine.message || 'unknown'}`);
+                            context.services.warn(`Browser engine install failed (qe-browser skill will be unavailable until you run \`aqe init --browser-engine\`): ${browserEngine.message || 'unknown'}`);
                             break;
                         case 'npm-unavailable':
-                            context.services.warn('Browser engine: npm not on PATH — install Node.js + npm, then `npm install -g vibium` to enable qe-browser');
+                            context.services.warn('Browser engine: npm not on PATH — install Node.js + npm, then `aqe init --browser-engine` to enable qe-browser');
                             break;
                         // 'already-installed' handled by the pre-flight branch above
                     }
@@ -141,12 +131,12 @@ export class AssetsPhase extends BasePhase {
                 const msg = error instanceof Error ? error.message : String(error);
                 context.services.warn(`Browser engine install error: ${msg}\n` +
                     `  qe-browser fleet skill will be unavailable until you run:\n` +
-                    `    npm install -g vibium\n` +
-                    `  Then re-run \`aqe init\` to verify. The rest of the AQE install will continue.`);
+                    `    npm install -g ${DEFAULT_VIBIUM_SPEC}\n` +
+                    `  Then re-run \`aqe init --browser-engine\` to verify. The rest of the AQE install will continue.`);
             }
         }
         else {
-            browserEngine = { status: 'skipped', packageSpec: DEFAULT_VIBIUM_SPEC, message: 'minimal mode' };
+            browserEngine = { status: 'skipped', packageSpec: DEFAULT_VIBIUM_SPEC, message: options.minimal ? 'minimal mode' : 'browser setup not requested; run aqe init --browser-engine' };
         }
         // Install n8n platform (optional)
         if (options.withN8n) {

package/dist/init/phases/phase-interface.d.ts

@@ -92,6 +92,8 @@ export interface InitOptions {
      */
     skipCodeIndex?: boolean;
     /** Minimal configuration (no skills, patterns, workers) */
+    /** Explicitly install the optional browser engine and browser payload. */
+    browserEngine?: boolean;
     minimal?: boolean;
     /** Automatically migrate from v2 if detected */
     /** Install n8n workflow testing platform */

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

@@ -15,7 +15,7 @@
  * - Automatic strategy recommendations
  * - Pattern quality improvement over time
  */
-import { RealQEReasoningBank, type RealQEReasoningBankConfig, type RealQERoutingRequest, type RealQERoutingResult, type LearningOutcome } from '../../../learning/real-qe-reasoning-bank.js';
+import { RealQEReasoningBank, type RealQEReasoningBankConfig, type RealQEPatternSearchResult, 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 { PatternEvolution, type PatternVersion, type DriftDetectionResult, type MergeCandidate, type PatternEvolutionConfig } from './pattern-evolution.js';
@@ -182,10 +182,7 @@ export declare class EnhancedReasoningBankAdapter {
         limit?: number;
         domain?: QEDomain;
         minSimilarity?: number;
-    }): Promise<Result<Array<{
-        pattern: QEPattern;
-        similarity: number;
-    }>>>;
+    }): Promise<Result<RealQEPatternSearchResult[]>>;
     /**
      * Record a pattern outcome with evolution tracking
      */

package/dist/integrations/ruvector/sona-persistence.d.ts

@@ -95,6 +95,7 @@ export declare class PersistentSONAEngine {
     private initPromise;
     private pendingSaves;
     private saveTimer;
+    private consecutiveSaveFailures;
     private serverClient;
     constructor(config: PersistentSONAConfig);
     /**

package/dist/integrations/ruvector/sona-persistence.js

@@ -112,6 +112,7 @@ export class PersistentSONAEngine {
     initPromise = null;
     pendingSaves = new Map();
     saveTimer = null;
+    consecutiveSaveFailures = 0;
     serverClient = null;
     constructor(config) {
         this.config = {
@@ -270,8 +271,6 @@ export class PersistentSONAEngine {
         ON CONFLICT(id) DO UPDATE SET
           confidence = excluded.confidence,
           usage_count = excluded.usage_count,
-          success_count = excluded.success_count,
-          failure_count = excluded.failure_count,
           metadata = excluded.metadata,
           updated_at = datetime('now'),
           last_used_at = excluded.last_used_at
@@ -288,6 +287,8 @@ export class PersistentSONAEngine {
         SET confidence = ?,
             success_count = success_count + ?,
             failure_count = failure_count + ?,
+            usage_count = usage_count + 1,
+            last_used_at = datetime('now'),
             updated_at = datetime('now')
         WHERE id = ?
       `));
@@ -432,6 +433,13 @@ export class PersistentSONAEngine {
             // Get updated pattern and persist confidence change
             const pattern = this.getPattern(patternId);
             if (pattern) {
+                // Feedback needs a durable row before incrementing its counters.
+                // Remove the queued snapshot only after its write succeeds.
+                const pending = this.pendingSaves.get(patternId);
+                if (pending) {
+                    this.savePatternToDb(pending);
+                    this.pendingSaves.delete(patternId);
+                }
                 this.persistPatternConfidenceUpdate(patternId, pattern.confidence, success ? 1 : 0, success ? 0 : 1);
             }
         }
@@ -548,19 +556,27 @@ export class PersistentSONAEngine {
         if (!stmt)
             throw new Error('Statement not prepared');
         const result = stmt.run(patternId);
-        return result.changes > 0;
+        // Delete queued writes too: otherwise the next batch or sync restores it.
+        const pending = this.pendingSaves.delete(patternId);
+        const cached = this.baseEngine.deletePattern(patternId);
+        return result.changes > 0 || pending || cached;
     }
     /**
      * Clear all patterns for this domain
      */
     clearDomainPatterns() {
         this.ensureInitialized();
-        // Clear in base engine
-        this.baseEngine.clear();
-        // Clear in SQLite for this domain
+        // Finish the durable delete first so a failed statement preserves memory.
         const stmt = this.prepared.get('deleteByDomain');
-        if (stmt) {
-            stmt.run(this.config.domain);
+        if (!stmt)
+            throw new Error('Statement not prepared');
+        stmt.run(this.config.domain);
+        for (const pattern of this.baseEngine.getPatternsByDomain(this.config.domain)) {
+            this.baseEngine.deletePattern(pattern.id);
+        }
+        for (const [id, pattern] of this.pendingSaves) {
+            if (pattern.domain === this.config.domain)
+                this.pendingSaves.delete(id);
         }
     }
     /**
@@ -791,10 +807,19 @@ export class PersistentSONAEngine {
             this.saveTimer = null;
         }
         if (this.pendingSaves.size > 0) {
+            const failures = [];
             for (const pattern of this.pendingSaves.values()) {
-                this.savePatternToDb(pattern);
+                try {
+                    this.savePatternToDb(pattern);
+                    this.pendingSaves.delete(pattern.id);
+                }
+                catch (error) {
+                    failures.push(new Error(toErrorMessage(error)));
+                }
+            }
+            if (failures.length > 0) {
+                throw new AggregateError(failures, `Deferred SONA saves failed: ${failures.map(error => error.message).join('; ')}`);
             }
-            this.pendingSaves.clear();
         }
         // A10 fix: checkpoint the request counter once per process lifetime
         // (cheap — not on the instantAdapt hot path) so short-lived CLI/MCP
@@ -813,6 +838,8 @@ export class PersistentSONAEngine {
         this.db = null;
         this.persistence = null;
         this.initialized = false;
+        // A completed initialization promise belongs to the closed lifecycle.
+        this.initPromise = null;
         console.log(`[PersistentSONAEngine] Closed: domain=${this.config.domain}`);
     }
     // ==========================================================================
@@ -1018,6 +1045,8 @@ export class PersistentSONAEngine {
         else {
             // Batch saves
             this.pendingSaves.set(pattern.id, pattern);
+            // New explicit work starts a fresh, bounded recovery cycle.
+            this.consecutiveSaveFailures = 0;
             this.scheduleSave();
         }
     }
@@ -1034,11 +1063,12 @@ export class PersistentSONAEngine {
         const actionEmbedding = pattern.action?.value && Array.isArray(pattern.action.value)
             ? this.floatArrayToBuffer(pattern.action.value)
             : null;
-        const actionValue = typeof pattern.action?.value === 'string'
-            ? pattern.action.value
-            : pattern.action?.value !== undefined
-                ? JSON.stringify(pattern.action.value)
-                : null;
+        // Encode strings too: the reader parses JSON, so raw "123"/"false"
+        // would otherwise change the action type after restarting. Legacy raw
+        // non-JSON strings remain readable through rowToPattern's fallback.
+        const actionValue = pattern.action?.value !== undefined
+            ? JSON.stringify(pattern.action.value)
+            : null;
         stmt.run(pattern.id, pattern.type, pattern.domain, stateEmbedding, actionEmbedding, pattern.action?.type ?? 'unknown', actionValue, pattern.outcome?.reward ?? 0, pattern.outcome?.success ? 1 : 0, pattern.outcome?.quality ?? 0, pattern.confidence, pattern.usageCount, 0, // success_count (tracked separately from usageCount)
         0, // failure_count
         pattern.metadata ? JSON.stringify(pattern.metadata) : null, pattern.createdAt?.toISOString() ?? new Date().toISOString(), pattern.lastUsedAt?.toISOString() ?? null);
@@ -1046,17 +1076,41 @@ export class PersistentSONAEngine {
     /**
      * Schedule batched save
      */
-    scheduleSave() {
-        if (this.saveTimer)
+    scheduleSave(delayMs = this.config.autoSaveInterval) {
+        if (this.saveTimer) {
+            // New explicit work must survive natural exit, even during a retry delay.
+            if (this.consecutiveSaveFailures === 0)
+                this.saveTimer.ref();
             return;
+        }
         this.saveTimer = setTimeout(() => {
             this.saveTimer = null;
             const patterns = Array.from(this.pendingSaves.values());
-            this.pendingSaves.clear();
             for (const pattern of patterns) {
-                this.savePatternToDb(pattern);
+                try {
+                    this.savePatternToDb(pattern);
+                    this.pendingSaves.delete(pattern.id);
+                }
+                catch (error) {
+                    logger.warn('Deferred SONA save failed; retaining pending pattern', {
+                        patternId: pattern.id, error: toErrorMessage(error),
+                    });
+                }
+            }
+            if (this.pendingSaves.size > 0) {
+                this.consecutiveSaveFailures++;
+                // Stop after five failed batches; close() can still flush retained rows.
+                if (this.consecutiveSaveFailures < 5 && this.db?.open) {
+                    this.scheduleSave(Math.min(60000, Math.max(1000, this.config.autoSaveInterval) * 2 ** (this.consecutiveSaveFailures - 1)));
+                }
+            }
+            else {
+                this.consecutiveSaveFailures = 0;
             }
-        }, this.config.autoSaveInterval);
+        }, delayMs);
+        // The initial batch must flush on natural exit; only failure retries are optional.
+        if (this.consecutiveSaveFailures > 0)
+            this.saveTimer.unref();
     }
     /**
      * Update pattern usage in SQLite

package/dist/integrations/ruvector/sona-wrapper.d.ts

@@ -199,6 +199,8 @@ export declare class QESONA {
      * Get statistics
      */
     getStats(): QESONAStats;
+    /** Stop recalling a pattern without resetting learned model weights. */
+    deletePattern(patternId: string): boolean;
     /**
      * Clear all patterns
      */

package/dist/integrations/ruvector/sona-wrapper.js

@@ -108,6 +108,15 @@ class QESONAPatternRegistry {
     getByDomain(domain) {
         return Array.from(this.patterns.values()).filter(p => p.domain === domain);
     }
+    /** Remove a pattern and its trajectory associations from the registry. */
+    delete(id) {
+        const removed = this.patterns.delete(id);
+        for (const [trajectoryId, patternId] of this.trajectoryMap) {
+            if (patternId === id)
+                this.trajectoryMap.delete(trajectoryId);
+        }
+        return removed;
+    }
     /**
      * Clear all patterns
      */
@@ -380,6 +389,10 @@ export class QESONA {
             engineStats,
         };
     }
+    /** Stop recalling a pattern without resetting learned model weights. */
+    deletePattern(patternId) {
+        return this.registry.delete(patternId);
+    }
     /**
      * Clear all patterns
      */

package/dist/integrations/vibium/client.d.ts

@@ -41,6 +41,7 @@ export declare class VibiumClientImpl implements VibiumClient {
     private _initialized;
     private _available;
     private vibeInstance;
+    private browserInstance;
     /**
      * Create a new Vibium client
      *

package/dist/integrations/vibium/client.js

@@ -7,6 +7,7 @@
  * @module integrations/vibium/client
  */
 import { randomUUID } from 'crypto';
+import { loadVibium, isVibiumReady, VIBIUM_SETUP } from './runtime.js';
 import { DEFAULT_VIBIUM_CONFIG } from './types.js';
 import { VibiumError, VibiumUnavailableError, VibiumTimeoutError, VibiumElementNotFoundError, VibiumConnectionError, VibiumNavigationError, VibiumScreenshotError, VibiumInteractionError, createVibiumError, } from './errors.js';
 import { toError } from '../../shared/error-utils.js';
@@ -24,7 +25,7 @@ async function getVibiumBrowser() {
         return vibiumBrowser;
     }
     try {
-        const vibium = await import('vibium');
+        const vibium = await loadVibium();
         vibiumBrowser = vibium.browser;
         vibiumAvailable = true;
         return vibiumBrowser;
@@ -112,6 +113,7 @@ export class VibiumClientImpl {
     _available = null;
     // Real Vibium browser instance
     vibeInstance = null;
+    browserInstance = null;
     /**
      * Create a new Vibium client
      *
@@ -133,7 +135,7 @@ export class VibiumClientImpl {
         try {
             // Check if Vibium package is available
             const browser = await getVibiumBrowser();
-            this._available = browser !== null;
+            this._available = browser !== null && isVibiumReady();
             return this._available;
         }
         catch {
@@ -157,7 +159,7 @@ export class VibiumClientImpl {
             if (isAvailable) {
                 this.lastHealthCheck = {
                     status: this.vibeInstance ? 'connected' : 'disconnected',
-                    version: '0.1.2', // From package.json
+                    // Runtime availability is checked against the installed payload.
                     browserType: this.config.browserType,
                     features: [
                         'browser-launch',
@@ -177,7 +179,7 @@ export class VibiumClientImpl {
                     status: 'unavailable',
                     features: ['fallback-only'],
                     lastChecked,
-                    error: 'Vibium package not available - install with: npm install vibium',
+                    error: `Vibium runtime or browser payload unavailable; run ${VIBIUM_SETUP}`,
                     sessionActive: false,
                 };
             }
@@ -209,13 +211,22 @@ export class VibiumClientImpl {
         const operation = async () => {
             const browser = await getVibiumBrowser();
             if (!browser) {
-                throw new VibiumUnavailableError('Vibium package not available. Install with: npm install vibium');
+                throw new VibiumUnavailableError(`Vibium runtime unavailable; run ${VIBIUM_SETUP}`);
             }
             // Launch REAL browser using Vibium
             const headless = options?.headless ?? this.config.headless;
-            this.vibeInstance = await browser.launch({
-                headless,
-            });
+            if (!isVibiumReady()) {
+                throw new VibiumUnavailableError(`Vibium browser payload unavailable; run ${VIBIUM_SETUP}`);
+            }
+            const instance = await browser.start({ headless });
+            try {
+                this.vibeInstance = await instance.page();
+                this.browserInstance = instance;
+            }
+            catch (error) {
+                await instance.stop();
+                throw error;
+            }
             const session = {
                 id: this.generateSessionId(),
                 browserType: this.config.browserType,
@@ -247,8 +258,9 @@ export class VibiumClientImpl {
         }
         const operation = async () => {
             if (this.vibeInstance) {
-                await this.vibeInstance.quit();
+                await this.browserInstance?.stop();
                 this.vibeInstance = null;
+                this.browserInstance = null;
             }
             this.currentSession = null;
         };
@@ -575,7 +587,7 @@ export class VibiumClientImpl {
         this.ensureSession();
         try {
             // Use real Vibium evaluate method
-            const result = await this.vibeInstance.evaluate(script);
+            const result = await this.vibeInstance.evaluate(`(async () => { ${script} })()`);
             return { success: true, value: result };
         }
         catch (error) {
@@ -608,13 +620,14 @@ export class VibiumClientImpl {
     async dispose() {
         if (this.vibeInstance) {
             try {
-                await this.vibeInstance.quit();
+                await this.browserInstance?.stop();
             }
             catch (error) {
                 // Non-critical: Vibium disposal errors
                 console.debug('[VibiumClient] Disposal error:', error instanceof Error ? error.message : error);
             }
             this.vibeInstance = null;
+            this.browserInstance = null;
         }
         this.currentSession = null;
         this._initialized = false;

package/dist/integrations/vibium/runtime.d.ts

@@ -0,0 +1,14 @@
+export declare const VIBIUM_SETUP = "aqe init --browser-engine (or npm install vibium@^26.8.21)";
+type Runtime = typeof import('vibium');
+/**
+ * How to run npm without a shell. On Windows `npm` is an `npm.cmd` shim, which
+ * execFile cannot start without `shell: true` (EINVAL/ENOENT since the
+ * CVE-2024-27980 fix), so run the npm CLI bundled next to node.exe instead.
+ * Falls back to plain `npm` when that layout is absent.
+ */
+export declare function npmInvocation(platform?: NodeJS.Platform, execPath?: string, exists?: (path: string) => boolean): [string, string[]];
+export declare function loadVibium(): Promise<Runtime>;
+/** Check the payload belonging to the resolved library, not a different PATH CLI. */
+export declare function isVibiumReady(): boolean;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/integrations/vibium/runtime.js

@@ -0,0 +1,94 @@
+/** Resolve the opt-in Vibium runtime for both local and global AQE installs. */
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export const VIBIUM_SETUP = 'aqe init --browser-engine (or npm install vibium@^26.8.21)';
+const requireFromHere = createRequire(import.meta.url);
+/**
+ * How to run npm without a shell. On Windows `npm` is an `npm.cmd` shim, which
+ * execFile cannot start without `shell: true` (EINVAL/ENOENT since the
+ * CVE-2024-27980 fix), so run the npm CLI bundled next to node.exe instead.
+ * Falls back to plain `npm` when that layout is absent.
+ */
+export function npmInvocation(platform = process.platform, execPath = process.execPath, exists = existsSync) {
+    if (platform === 'win32') {
+        const npmCli = join(dirname(execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
+        if (exists(npmCli))
+            return [execPath, [npmCli]];
+    }
+    return ['npm', []];
+}
+/** Never install or download anything while probing availability. */
+function resolveRuntime() {
+    try {
+        return requireFromHere.resolve('vibium');
+    }
+    catch {
+        try {
+            return createRequire(join(process.cwd(), 'package.json')).resolve('vibium');
+        }
+        catch { /* No project-local opt-in runtime. Try global setup below. */ }
+        // A global CLI installation is not on Node's normal module search path.
+        // npm root is read-only and honors the same npm prefix as explicit setup.
+        const [npmBin, npmPrefixArgs] = npmInvocation();
+        const root = execFileSync(npmBin, [...npmPrefixArgs, 'root', '-g'], {
+            encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        return requireFromHere.resolve(join(root, 'vibium'));
+    }
+}
+/**
+ * Accept the modern API from the namespace itself or from its `default`
+ * export. CJS interop and bundler createRequire shims expose the package
+ * object only as `default`, so checking the namespace alone rejects a
+ * correctly installed runtime.
+ */
+function selectBrowserApi(loaded) {
+    if (typeof loaded?.browser?.start === 'function')
+        return loaded;
+    if (typeof loaded?.default?.browser?.start === 'function')
+        return loaded.default;
+    return null;
+}
+export async function loadVibium() {
+    let loaded;
+    try {
+        loaded = await import('vibium');
+    }
+    catch (error) {
+        // Only a missing local package permits global resolution. A broken local
+        // installation must not be silently replaced by an unrelated runtime.
+        if (error.code !== 'ERR_MODULE_NOT_FOUND' &&
+            error.code !== 'MODULE_NOT_FOUND')
+            throw error;
+        let entry;
+        try {
+            entry = resolveRuntime();
+        }
+        catch (cause) {
+            throw new Error(`Vibium is not installed; run ${VIBIUM_SETUP}`, { cause });
+        }
+        loaded = requireFromHere(entry);
+    }
+    const runtime = selectBrowserApi(loaded);
+    if (!runtime) {
+        throw new Error('Unsupported Vibium API: the installed package exposes no browser.start() ' +
+            `(neither as a named nor a default export); run ${VIBIUM_SETUP}`);
+    }
+    return runtime;
+}
+/** Check the payload belonging to the resolved library, not a different PATH CLI. */
+export function isVibiumReady() {
+    try {
+        const cli = join(dirname(resolveRuntime()), '..', 'bin', 'cli.js');
+        execFileSync(process.execPath, [cli, 'is-installed'], {
+            timeout: 5000, stdio: 'ignore',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/dist/kernel/memory-backend.js

@@ -56,9 +56,9 @@ export class InMemoryBackend {
         return value !== undefined;
     }
     async search(pattern, limit = MEMORY_CONSTANTS.DEFAULT_SEARCH_LIMIT, options) {
-        // Escape regex-special chars first, then convert glob wildcards to regex
-        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-        const regex = new RegExp(escaped.replace(/\*/g, '.*'));
+        // Match the same whole-key glob contract as persistent memory.
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 'su');
         const results = [];
         // When a namespace is supplied, scope the scan to that prefix. Matches
         // HybridBackend's namespace-aware search and lets LearningCoordinator's
@@ -68,7 +68,8 @@ export class InMemoryBackend {
         for (const key of this.store.keys()) {
             if (nsPrefix && !key.startsWith(nsPrefix))
                 continue;
-            if (regex.test(key)) {
+            const searchableKey = nsPrefix ? key.slice(nsPrefix.length) : key;
+            if (regex.test(searchableKey)) {
                 results.push(key);
                 if (results.length >= limit)
                     break;