monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/production/rate-limiter.js

@@ -33,6 +33,11 @@ export class RateLimiter {
      * Check if a request is allowed
      */
     check(operation, userId) {
+        // Cap operation and userId lengths so bucket keys cannot inflate the Map
+        const safeOp = typeof operation === 'string' ? operation.slice(0, 256) : 'unknown';
+        const safeUserId = userId ? userId.slice(0, 256) : undefined;
+        operation = safeOp;
+        userId = safeUserId;
         // Check whitelist
         if (this.config.whitelist.includes(operation)) {
             return { allowed: true, remaining: Infinity, resetAt: 0 };
@@ -157,10 +162,14 @@ export class RateLimiter {
     // Private Methods
     // ============================================================================
     getLimits(operation) {
-        return (this.config.operationLimits[operation] || {
-            maxRequests: this.config.maxRequests,
-            windowMs: this.config.windowMs,
-        });
+        // Object.hasOwn guards against prototype-pollution: if someone passes
+        // '__proto__' as the operation name, falling through to the default is safe.
+        return (Object.hasOwn(this.config.operationLimits, operation)
+            ? this.config.operationLimits[operation]
+            : {
+                maxRequests: this.config.maxRequests,
+                windowMs: this.config.windowMs,
+            });
     }
     createBucket() {
         return {

package/packages/@monomind/cli/dist/src/production/retry.js

@@ -59,13 +59,15 @@ function calculateDelay(attempt, config, strategy = 'exponential') {
     return Math.round(Math.max(0, delay));
 }
 /**
- * Fibonacci helper for fibonacci backoff
+ * Fibonacci helper for fibonacci backoff — capped at n=40 to prevent
+ * excessively long loops when maxAttempts is set to a large value.
  */
 function fibonacci(n) {
-    if (n <= 1)
+    const capped = Math.min(n, 40);
+    if (capped <= 1)
         return 1;
     let a = 1, b = 1;
-    for (let i = 2; i <= n; i++) {
+    for (let i = 2; i <= capped; i++) {
         [a, b] = [b, a + b];
     }
     return b;
@@ -99,8 +101,12 @@ function sleep(ms) {
  */
 export async function withRetry(fn, config = {}, strategy = 'exponential') {
     const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    // Clamp maxAttempts and maxDelayMs to safe ranges to prevent runaway retry loops
+    finalConfig.maxAttempts = Math.min(Math.max(1, finalConfig.maxAttempts), 100);
+    finalConfig.maxDelayMs = Math.min(Math.max(0, finalConfig.maxDelayMs), 300_000); // 5 min ceiling
     const startTime = Date.now();
     const retryHistory = [];
+    const MAX_RETRY_HISTORY = 100;
     let lastError;
     let attempt = 0;
     while (attempt < finalConfig.maxAttempts) {
@@ -129,12 +135,14 @@ export async function withRetry(fn, config = {}, strategy = 'exponential') {
             }
             // Calculate delay
             const delay = calculateDelay(attempt, finalConfig, strategy);
-            // Record retry
-            retryHistory.push({
-                attempt,
-                error: lastError.message,
-                delayMs: delay,
-            });
+            // Record retry (cap history size and error message length to prevent OOM)
+            if (retryHistory.length < MAX_RETRY_HISTORY) {
+                retryHistory.push({
+                    attempt,
+                    error: lastError.message.slice(0, 512),
+                    delayMs: delay,
+                });
+            }
             // Call retry callback
             if (finalConfig.onRetry) {
                 finalConfig.onRetry(lastError, attempt, delay);

package/packages/@monomind/cli/dist/src/routing/embed-worker.js

@@ -22,12 +22,16 @@ import { createSemanticRouting } from './embedder.js';
 // don't land on stdout and corrupt the single JSON result line the parent
 // parses. Must be set before the (lazy) transformers import in embedder.ts.
 process.env.TRANSFORMERS_VERBOSITY ??= 'error';
+/** Max task string length before it's silently truncated — prevents OOM in the embedding model. */
+const MAX_TASK_LENGTH = 2_000;
 async function main() {
-    const task = process.argv[2];
-    if (!task) {
+    const rawTask = process.argv[2];
+    if (!rawTask) {
         process.stderr.write('embed-worker: missing task argument\n');
         process.exit(2);
     }
+    // Cap the task to prevent OOM when an oversized string is passed to the embedding model.
+    const task = rawTask.length > MAX_TASK_LENGTH ? rawTask.slice(0, MAX_TASK_LENGTH) : rawTask;
     const { RouteLayer, ALL_ROUTES } = await import('@monomind/routing');
     const semantic = await createSemanticRouting(ALL_ROUTES);
     if (!semantic) {

package/packages/@monomind/cli/dist/src/routing/llm-caller.js

@@ -16,6 +16,8 @@ import { spawn, execSync } from 'child_process';
 import { tmpdir } from 'os';
 /** Default model for routing fallback — Haiku is fast and cheap for slug classification. */
 const DEFAULT_ROUTING_MODEL = 'haiku';
+/** Runtime-validated set of allowed model aliases. */
+const ALLOWED_MODELS = new Set(['haiku', 'sonnet', 'opus']);
 /**
  * Max time to wait for a single classification before giving up.
  * `claude --print` is a full headless session (cold start ~10s, can spike),
@@ -23,6 +25,8 @@ const DEFAULT_ROUTING_MODEL = 'haiku';
  * on timeout rather than blocking the caller.
  */
 const DEFAULT_TIMEOUT_MS = 45_000;
+/** Hard upper cap on caller-supplied timeoutMs — prevents disabling the SIGTERM/SIGKILL guard. */
+const MAX_TIMEOUT_MS = 120_000;
 /** Cap captured output so a runaway child can't grow parent memory unbounded. */
 const MAX_OUTPUT = 1024 * 1024; // 1 MB — a slug response is tiny
 let claudeAvailable = null;
@@ -49,8 +53,15 @@ export function isClaudeCodeAvailable() {
 export function createClaudeLLMCaller(options = {}) {
     if (!isClaudeCodeAvailable())
         return null;
-    const model = options.model ?? DEFAULT_ROUTING_MODEL;
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    // Runtime enum guard — TypeScript union is compile-time only; JS callers
+    // could otherwise inject an arbitrary string into the --model flag.
+    const rawModel = options.model ?? DEFAULT_ROUTING_MODEL;
+    const model = ALLOWED_MODELS.has(rawModel) ? rawModel : DEFAULT_ROUTING_MODEL;
+    // Cap caller-supplied timeout so a huge value can't disable the SIGTERM/SIGKILL guard.
+    const rawTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = Math.min(typeof rawTimeout === 'number' && Number.isFinite(rawTimeout) && rawTimeout > 0
+        ? rawTimeout
+        : DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
     const cwd = options.cwd ?? tmpdir();
     return (prompt) => new Promise((resolve, reject) => {
         const env = { ...process.env };

package/packages/@monomind/cli/dist/src/routing/route-layer-factory.js

@@ -25,12 +25,20 @@ const WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), 'embed-worker.
 const WORKER_TIMEOUT_MS = 90_000;
 /** Cap worker stdout so a runaway child can't grow parent memory unbounded. */
 const MAX_WORKER_OUTPUT = 4 * 1024 * 1024; // 4 MB
+/** Cap the task string length to prevent OOM/DoS via oversized argv. */
+const MAX_TASK_LENGTH = 2_000;
+/** Cap stderr reflected in error messages to prevent log-inflation attacks. */
+const MAX_STDERR_IN_ERROR = 500;
+/** Cap allScores array passed to the LLM fallback to prevent downstream OOM. */
+const MAX_ALL_SCORES = 100;
 /** Marker the worker prefixes its result line with (see embed-worker.ts). */
 const RESULT_MARKER = '__ROUTE_RESULT__';
 /** Run the embedding worker for one task. Resolves the RouteResult, or rejects. */
 function runWorker(task) {
+    // Cap task length before passing as argv to prevent OOM/DoS via oversized args.
+    const safeTask = task.length > MAX_TASK_LENGTH ? task.slice(0, MAX_TASK_LENGTH) : task;
     return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [WORKER_PATH, task], {
+        const child = spawn(process.execPath, [WORKER_PATH, safeTask], {
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: true,
         });
@@ -75,7 +83,10 @@ function runWorker(task) {
             settled = true;
             clearTimeout(timer);
             if (code !== 0) {
-                reject(new Error(stderr.trim() || `worker exited ${code}`));
+                // Truncate stderr before embedding in Error to prevent log-inflation via
+                // a malicious or runaway child writing oversized diagnostic output.
+                const stderrSnippet = stderr.trim().slice(0, MAX_STDERR_IN_ERROR);
+                reject(new Error(stderrSnippet || `worker exited ${code}`));
                 return;
             }
             // Extract the marked result line — model-loader output may have written
@@ -130,8 +141,12 @@ export async function createConfiguredRouteLayer(opts = {}) {
                 }
                 // 3. Below threshold → Claude fallback in the parent, reusing scores.
                 if (llmCaller && Array.isArray(semantic.allScores) && semantic.allScores.length) {
+                    // Cap allScores to prevent downstream OOM if the worker sends an oversized array.
+                    const scores = semantic.allScores.length > MAX_ALL_SCORES
+                        ? semantic.allScores.slice(0, MAX_ALL_SCORES)
+                        : semantic.allScores;
                     const fallback = new LLMFallbackRouter({ llmCaller, model: 'haiku' });
-                    return fallback.classify(taskDescription, ALL_ROUTES, semantic.allScores);
+                    return fallback.classify(taskDescription, ALL_ROUTES, scores);
                 }
                 if (!opts.debug)
                     delete semantic.allScores;

package/packages/@monomind/cli/dist/src/runtime/headless.d.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * Headless Runtime for Background Workers
+ * Runs without TTY for daemon processes and scheduled tasks
+ *
+ * Usage:
+ *   npx @monomind/cli headless --worker <type>
+ *   npx @monomind/cli headless --daemon
+ *   npx @monomind/cli headless --benchmark
+ *
+ * Environment:
+ *   MONOMIND_HEADLESS=true
+ *   CLAUDE_CODE_HEADLESS=true
+ *
+ * @module v1/cli/runtime/headless
+ */
+import { type HeadlessWorkerType } from '../services/headless-worker-executor.js';
+interface HeadlessConfig {
+    mode: 'worker' | 'daemon' | 'benchmark' | 'status';
+    workerType?: HeadlessWorkerType;
+    timeout?: number;
+    verbose?: boolean;
+}
+interface BenchmarkResults {
+    sona: {
+        avgMs: number;
+        targetMet: boolean;
+    };
+    flashAttention: {
+        throughputPerMs: number;
+        speedup: number;
+    };
+    hnsw: {
+        entriesIndexed: number;
+        searchTime: number;
+    };
+}
+/**
+ * Run a specific worker
+ */
+declare function runWorker(workerType: HeadlessWorkerType, timeout: number): Promise<void>;
+/**
+ * Run daemon mode
+ */
+declare function runDaemon(): Promise<void>;
+/**
+ * Run benchmarks
+ */
+declare function runBenchmarks(): Promise<BenchmarkResults>;
+/**
+ * Show system status
+ */
+declare function showStatus(): Promise<void>;
+/**
+ * Main entry point
+ */
+declare function main(): Promise<void>;
+export { main, runWorker, runDaemon, runBenchmarks, showStatus };
+export type { HeadlessConfig, BenchmarkResults };
+//# sourceMappingURL=headless.d.ts.map

package/packages/@monomind/cli/dist/src/runtime/headless.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * Headless Runtime for Background Workers
+ * Runs without TTY for daemon processes and scheduled tasks
+ *
+ * Usage:
+ *   npx @monomind/cli headless --worker <type>
+ *   npx @monomind/cli headless --daemon
+ *   npx @monomind/cli headless --benchmark
+ *
+ * Environment:
+ *   MONOMIND_HEADLESS=true
+ *   CLAUDE_CODE_HEADLESS=true
+ *
+ * @module v1/cli/runtime/headless
+ */
+import { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES } from '../services/headless-worker-executor.js';
+import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
+import { initializeIntelligence, benchmarkAdaptation, getIntelligenceStats } from '../memory/intelligence.js';
+import { getHNSWStatus, batchCosineSim, flashAttentionSearch } from '../memory/memory-initializer.js';
+// ============================================================================
+// Main Runtime
+// ============================================================================
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        mode: 'status',
+        verbose: false
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--worker' || arg === '-w') {
+            config.mode = 'worker';
+            config.workerType = args[++i];
+        }
+        else if (arg === '--daemon' || arg === '-d') {
+            config.mode = 'daemon';
+        }
+        else if (arg === '--benchmark' || arg === '-b') {
+            config.mode = 'benchmark';
+        }
+        else if (arg === '--status' || arg === '-s') {
+            config.mode = 'status';
+        }
+        else if (arg === '--timeout' || arg === '-t') {
+            config.timeout = parseInt(args[++i], 10) || 60000;
+        }
+        else if (arg === '--verbose' || arg === '-v') {
+            config.verbose = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            showHelp();
+            process.exit(0);
+        }
+    }
+    return config;
+}
+/**
+ * Show help message
+ */
+function showHelp() {
+    console.log(`
+Headless Runtime for Monomind
+
+Usage:
+  headless --worker <type>    Run a specific worker
+  headless --daemon           Start background daemon
+  headless --benchmark        Run performance benchmarks
+  headless --status           Show system status
+
+Workers: ${HEADLESS_WORKER_TYPES.join(', ')}
+
+Options:
+  -w, --worker <type>   Worker type to run
+  -d, --daemon          Run as daemon
+  -b, --benchmark       Run benchmarks
+  -s, --status          Show status
+  -t, --timeout <ms>    Execution timeout (default: 60000)
+  -v, --verbose         Verbose output
+  -h, --help            Show help
+
+Environment:
+  MONOMIND_HEADLESS=true   Enable headless mode
+  CLAUDE_CODE_HEADLESS=true   Enable Claude Code headless
+
+Examples:
+  headless --worker audit --timeout 120000
+  headless --daemon
+  headless --benchmark
+`);
+}
+/**
+ * Run a specific worker
+ */
+async function runWorker(workerType, timeout) {
+    console.log(`[Headless] Starting worker: ${workerType}`);
+    const executor = new HeadlessWorkerExecutor(process.cwd(), {
+        maxConcurrent: 1,
+        defaultTimeoutMs: timeout
+    });
+    try {
+        const result = await executor.execute(workerType, {
+            timeoutMs: timeout,
+            model: 'sonnet',
+            sandbox: 'permissive'
+        });
+        if (result.success) {
+            console.log(`[Headless] Worker ${workerType} completed successfully`);
+            console.log(`[Headless] Duration: ${result.durationMs}ms`);
+            if (result.output) {
+                console.log(`[Headless] Output: ${JSON.stringify(result.output).slice(0, 500)}...`);
+            }
+        }
+        else {
+            console.error(`[Headless] Worker ${workerType} failed: ${result.error}`);
+            process.exit(1);
+        }
+    }
+    finally {
+        // executor doesn't have shutdown, just let it be garbage collected
+    }
+}
+/**
+ * Run daemon mode
+ */
+async function runDaemon() {
+    console.log('[Headless] Starting daemon mode...');
+    // Start the daemon
+    const daemon = await startDaemon(process.cwd());
+    console.log('[Headless] Daemon started');
+    console.log('[Headless] Press Ctrl+C to stop');
+    // Handle shutdown
+    process.on('SIGINT', async () => {
+        console.log('\n[Headless] Shutting down daemon...');
+        await stopDaemon();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        console.log('\n[Headless] Received SIGTERM, shutting down...');
+        await stopDaemon();
+        process.exit(0);
+    });
+    // Keep process running
+    await new Promise(() => { });
+}
+/**
+ * Run benchmarks
+ */
+async function runBenchmarks() {
+    console.log('=== Monomind Performance Benchmarks ===\n');
+    // Initialize intelligence
+    await initializeIntelligence();
+    // SONA Benchmark
+    console.log('1. SONA Adaptation Benchmark (10,000 iterations)...');
+    const sonaResult = benchmarkAdaptation(10000);
+    console.log(`   Average: ${sonaResult.avgMs.toFixed(4)}ms`);
+    console.log(`   Target (<0.05ms): ${sonaResult.targetMet ? '✅ ACHIEVED' : '❌ NOT MET'}`);
+    // Flash Attention Benchmark
+    console.log('\n2. Flash Attention Search Benchmark...');
+    const dim = 384;
+    const count = 10000;
+    const query = new Float32Array(dim).map(() => Math.random() - 0.5);
+    const vectors = Array.from({ length: count }, () => new Float32Array(dim).map(() => Math.random() - 0.5));
+    // Warmup
+    flashAttentionSearch(query, vectors, { k: 10 });
+    const flashStart = performance.now();
+    for (let i = 0; i < 10; i++) {
+        flashAttentionSearch(query, vectors, { k: 10 });
+    }
+    const flashTime = (performance.now() - flashStart) / 10;
+    const throughput = count / flashTime;
+    // Brute force comparison
+    const bruteStart = performance.now();
+    for (let i = 0; i < 10; i++) {
+        const scores = batchCosineSim(query, vectors);
+        Array.from({ length: count }, (_, i) => i)
+            .sort((a, b) => scores[b] - scores[a])
+            .slice(0, 10);
+    }
+    const bruteTime = (performance.now() - bruteStart) / 10;
+    const speedup = bruteTime / flashTime;
+    console.log(`   Throughput: ${throughput.toFixed(0)} vectors/ms`);
+    console.log(`   Time for 10k vectors: ${flashTime.toFixed(2)}ms`);
+    console.log(`   Speedup vs brute force: ${speedup.toFixed(2)}x`);
+    // HNSW Status
+    console.log('\n3. HNSW Index Status...');
+    const hnswStatus = getHNSWStatus();
+    console.log(`   Entries indexed: ${hnswStatus.entryCount}`);
+    console.log(`   Initialized: ${hnswStatus.initialized}`);
+    // Intelligence Stats
+    console.log('\n4. Intelligence System Stats...');
+    const stats = getIntelligenceStats();
+    console.log(`   SONA enabled: ${stats.sonaEnabled}`);
+    console.log(`   Patterns learned: ${stats.patternsLearned}`);
+    console.log(`   Avg adaptation time: ${stats.avgAdaptationTime.toFixed(4)}ms`);
+    console.log('\n=== Benchmark Complete ===');
+    return {
+        sona: {
+            avgMs: sonaResult.avgMs,
+            targetMet: sonaResult.targetMet
+        },
+        flashAttention: {
+            throughputPerMs: throughput,
+            speedup
+        },
+        hnsw: {
+            entriesIndexed: hnswStatus.entryCount,
+            searchTime: flashTime
+        }
+    };
+}
+/**
+ * Show system status
+ */
+async function showStatus() {
+    console.log('=== Monomind System Status ===\n');
+    // Check daemon
+    const daemon = getDaemon();
+    console.log('Daemon:');
+    if (daemon) {
+        const status = daemon.getStatus();
+        console.log(`  Running: ${status.running}`);
+        console.log(`  PID: ${status.pid}`);
+        console.log(`  Workers: ${status.workers.size}`);
+    }
+    else {
+        console.log('  Not initialized');
+    }
+    // Intelligence
+    const stats = getIntelligenceStats();
+    console.log('\nIntelligence:');
+    console.log(`  SONA enabled: ${stats.sonaEnabled}`);
+    console.log(`  ReasoningBank size: ${stats.reasoningBankSize}`);
+    console.log(`  Patterns learned: ${stats.patternsLearned}`);
+    // HNSW
+    const hnsw = getHNSWStatus();
+    console.log('\nHNSW Index:');
+    console.log(`  Initialized: ${hnsw.initialized}`);
+    console.log(`  Entries: ${hnsw.entryCount}`);
+    console.log('\nEnvironment:');
+    console.log(`  MONOMIND_HEADLESS: ${process.env.MONOMIND_HEADLESS || 'not set'}`);
+    console.log(`  CLAUDE_CODE_HEADLESS: ${process.env.CLAUDE_CODE_HEADLESS || 'not set'}`);
+    console.log(`  NODE_ENV: ${process.env.NODE_ENV || 'development'}`);
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    // Set headless environment
+    process.env.MONOMIND_HEADLESS = 'true';
+    const config = parseArgs();
+    try {
+        switch (config.mode) {
+            case 'worker':
+                if (!config.workerType || !HEADLESS_WORKER_TYPES.includes(config.workerType)) {
+                    console.error(`Invalid worker type. Available: ${HEADLESS_WORKER_TYPES.join(', ')}`);
+                    process.exit(1);
+                }
+                await runWorker(config.workerType, config.timeout || 60000);
+                break;
+            case 'daemon':
+                await runDaemon();
+                break;
+            case 'benchmark':
+                await runBenchmarks();
+                break;
+            case 'status':
+            default:
+                await showStatus();
+                break;
+        }
+    }
+    catch (error) {
+        console.error('[Headless] Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+// Run if executed directly
+main().catch(console.error);
+export { main, runWorker, runDaemon, runBenchmarks, showStatus };
+//# sourceMappingURL=headless.js.map

package/packages/@monomind/cli/dist/src/services/agentic-flow-bridge.d.ts

@@ -0,0 +1,50 @@
+/**
+ * agentic-flow v1 integration bridge
+ *
+ * Provides a single lazy-loading entry point for all agentic-flow v1
+ * subpath exports. Every accessor returns `null` when agentic-flow is
+ * not installed — callers never throw on missing optional dependency.
+ *
+ * @module agentic-flow-bridge
+ */
+/**
+ * Load the ReasoningBank module (4-step learning pipeline).
+ * Returns null if agentic-flow is not installed.
+ * Race-safe: concurrent callers share the same import Promise.
+ */
+export declare function getReasoningBank(): Promise<typeof import("agentic-flow/reasoningbank") | null>;
+/**
+ * Load the ModelRouter module (multi-provider LLM routing).
+ * Returns null if agentic-flow is not installed.
+ */
+export declare function getRouter(): Promise<typeof import("agentic-flow/router") | null>;
+/**
+ * Load the Orchestration module (workflow engine).
+ * Returns null if agentic-flow is not installed.
+ */
+export declare function getOrchestration(): Promise<typeof import("agentic-flow/orchestration") | null>;
+/**
+ * Compute an embedding vector via ReasoningBank, falling back to null.
+ */
+export declare function computeEmbedding(text: string): Promise<number[] | null>;
+/**
+ * Retrieve memories matching a query via ReasoningBank.
+ */
+export declare function retrieveMemories(query: string, opts?: {
+    k?: number;
+}): Promise<any[]>;
+/**
+ * Check whether agentic-flow v1 is available at runtime.
+ */
+export declare function isAvailable(): Promise<boolean>;
+/**
+ * Return a summary of available agentic-flow v1 capabilities.
+ */
+export declare function capabilities(): Promise<{
+    available: boolean;
+    reasoningBank: boolean;
+    router: boolean;
+    orchestration: boolean;
+    version: string | null;
+}>;
+//# sourceMappingURL=agentic-flow-bridge.d.ts.map

package/packages/@monomind/cli/dist/src/services/agentic-flow-bridge.js

@@ -0,0 +1,95 @@
+/**
+ * agentic-flow v1 integration bridge
+ *
+ * Provides a single lazy-loading entry point for all agentic-flow v1
+ * subpath exports. Every accessor returns `null` when agentic-flow is
+ * not installed — callers never throw on missing optional dependency.
+ *
+ * @module agentic-flow-bridge
+ */
+// ---------------------------------------------------------------------------
+// Cached module handles (Promise-based to prevent TOCTOU races)
+// ---------------------------------------------------------------------------
+let _reasoningBankP = null;
+let _routerP = null;
+let _orchestrationP = null;
+// ---------------------------------------------------------------------------
+// Public loaders
+// ---------------------------------------------------------------------------
+/**
+ * Load the ReasoningBank module (4-step learning pipeline).
+ * Returns null if agentic-flow is not installed.
+ * Race-safe: concurrent callers share the same import Promise.
+ */
+export function getReasoningBank() {
+    if (_reasoningBankP === null) {
+        _reasoningBankP = import('agentic-flow/reasoningbank').catch(() => null);
+    }
+    return _reasoningBankP;
+}
+/**
+ * Load the ModelRouter module (multi-provider LLM routing).
+ * Returns null if agentic-flow is not installed.
+ */
+export function getRouter() {
+    if (_routerP === null) {
+        _routerP = import('agentic-flow/router').catch(() => null);
+    }
+    return _routerP;
+}
+/**
+ * Load the Orchestration module (workflow engine).
+ * Returns null if agentic-flow is not installed.
+ */
+export function getOrchestration() {
+    if (_orchestrationP === null) {
+        _orchestrationP = import('agentic-flow/orchestration').catch(() => null);
+    }
+    return _orchestrationP;
+}
+// ---------------------------------------------------------------------------
+// Convenience helpers
+// ---------------------------------------------------------------------------
+/**
+ * Compute an embedding vector via ReasoningBank, falling back to null.
+ */
+export async function computeEmbedding(text) {
+    const rb = await getReasoningBank();
+    if (!rb?.computeEmbedding)
+        return null;
+    return rb.computeEmbedding(text);
+}
+/**
+ * Retrieve memories matching a query via ReasoningBank.
+ */
+export async function retrieveMemories(query, opts) {
+    const rb = await getReasoningBank();
+    if (!rb?.retrieveMemories)
+        return [];
+    return rb.retrieveMemories(query, opts);
+}
+/**
+ * Check whether agentic-flow v1 is available at runtime.
+ */
+export async function isAvailable() {
+    const rb = await getReasoningBank();
+    return rb !== null;
+}
+/**
+ * Return a summary of available agentic-flow v1 capabilities.
+ */
+export async function capabilities() {
+    const [rb, router, orch] = await Promise.all([
+        getReasoningBank(),
+        getRouter(),
+        getOrchestration(),
+    ]);
+    return {
+        available: rb !== null || router !== null || orch !== null,
+        reasoningBank: rb !== null,
+        router: router !== null,
+        orchestration: orch !== null,
+        version: rb?.VERSION ?? null,
+    };
+}
+//# sourceMappingURL=agentic-flow-bridge.js.map