monomind 1.14.6 → 1.15.0

package/packages/@monomind/cli/dist/src/mcp-tools/monograph-tools.js

@@ -575,12 +575,18 @@ async function computeCommitsBehind(repoPath) {
         closeDb(db);
     }
 }
+/**
+ * Shared staleness threshold: both monograph_staleness and monograph_suggest_auto
+ * trigger a background rebuild only when the index is more than this many commits behind HEAD.
+ * Using a shared constant prevents conflicting rebuild pressure during active dev sessions.
+ */
+const STALENESS_THRESHOLD = 10;
 /**
  * Fire-and-forget background rebuild. Uses a module-level guard so concurrent
  * MCP tool calls (e.g. repeated monograph_suggest_auto) don't pile up builds.
- * threshold: minimum commitsBehind to trigger (default 1, Task 2 uses 10).
+ * threshold: minimum commitsBehind to trigger (default STALENESS_THRESHOLD + 1).
  */
-function triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, threshold = 1) {
+function triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, threshold = STALENESS_THRESHOLD + 1) {
     if (commitsBehind < threshold)
         return false;
     if (_buildInProgress)
@@ -609,8 +615,7 @@ const monographStalenessTool = {
             return text(JSON.stringify({ commitsBehind: 0, status: 'unknown', triggered: false }));
         }
         const { commitsBehind } = result;
-        const AUTO_BUILD_THRESHOLD = 10;
-        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, AUTO_BUILD_THRESHOLD + 1);
+        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, STALENESS_THRESHOLD + 1);
         const status = triggered ? 'building' : commitsBehind === 0 ? 'fresh' : 'stale';
         return text(JSON.stringify({ commitsBehind, status, triggered }));
     },
@@ -895,22 +900,25 @@ const monographImpactTool = {
                 filePath: impactPath,
                 depth,
             });
-            if (!result || !result.root)
+            if (!result || !result.node)
                 return text(`No symbol found: ${impactName}`);
             // Format impact as structured text for direct LLM consumption
-            const root = result.root;
+            const root = result.node;
             const rootLoc = root.filePath ? (root.startLine != null ? `${root.filePath}:${root.startLine}` : root.filePath) : '';
             const lines = [
                 `[${root.label ?? '?'}] ${root.name}  ${rootLoc}`,
                 '',
-                `Blast radius: ${result.totalAffected ?? 0} symbols affected`,
+                `Blast radius: ${result.affectedFiles?.length ?? 0} symbols affected`,
             ];
             if (result.riskScore != null) {
                 const riskLabel = result.riskScore >= 0.8 ? 'HIGH' : result.riskScore >= 0.5 ? 'MEDIUM' : 'LOW';
                 lines.push(`Risk score: ${result.riskScore.toFixed(2)} (${riskLabel})`);
             }
             lines.push('');
-            const affected = (result.affected ?? result.callers ?? []);
+            const affected = [
+                ...(result.directCallers ?? []),
+                ...(result.transitiveCallers ?? []).flatMap(t => t.nodes ?? []),
+            ];
             if (affected.length > 0) {
                 lines.push(`Affected callers (${affected.length}):`);
                 for (const sym of affected.slice(0, 20)) {
@@ -1210,11 +1218,13 @@ const monographGroupListTool = {
         const { getGroupList } = await import('@monoes/monograph');
         const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
         const result = await getGroupList(configPath);
-        if (!result.repos || result.repos.length === 0) {
-            return text(`Group: ${result.group?.name ?? 'unknown'}\nNo repos configured. Check ${configPath}`);
+        const firstGroup = result.groups?.[0];
+        const allRepos = result.groups?.flatMap((g) => g.repos ?? []) ?? [];
+        if (!allRepos.length) {
+            return text(`Group: ${firstGroup?.name ?? 'unknown'}\nNo repos configured. Check ${configPath}`);
         }
-        const lines = [`Group: ${result.group?.name ?? 'unknown'}  (${result.repos.length} repos)`];
-        for (const r of result.repos) {
+        const lines = [`Group: ${firstGroup?.name ?? 'unknown'}  (${allRepos.length} repos)`];
+        for (const r of allRepos) {
             const indexed = r.indexedAt ? r.indexedAt.slice(0, 10) : 'never';
             lines.push(`  ${r.name}  nodes=${r.nodeCount}  indexed=${indexed}  ${r.path}`);
         }
@@ -1786,10 +1796,10 @@ const monographSuggestAutoTool = {
     },
     handler: async (input) => {
         const repoPath = getProjectCwd();
-        // Check staleness and trigger rebuild if needed (threshold: any staleness).
+        // Check staleness and trigger rebuild if needed (threshold: STALENESS_THRESHOLD commits).
         const stalenessResult = await computeCommitsBehind(repoPath);
         const commitsBehind = stalenessResult?.commitsBehind ?? 0;
-        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, 1);
+        const triggered = triggerBackgroundBuildIfNeeded(repoPath, commitsBehind, STALENESS_THRESHOLD + 1);
         const stalenessStatus = triggered ? 'building' : commitsBehind === 0 ? 'fresh' : 'stale';
         // Delegate to the base suggest tool — no logic duplication.
         const baseResult = await monographSuggestTool.handler(input);

package/packages/@monomind/cli/dist/src/mcp-tools/workflow-tools.js

@@ -75,7 +75,7 @@ const FORBIDDEN_WORKFLOW_IDS = new Set(['__proto__', 'constructor', 'prototype']
 export const workflowTools = [
     {
         name: 'workflow_run',
-        description: 'Run a workflow from a template or file',
+        description: 'Create a swarm workflow stage record from a template (feature/bugfix/refactor/security). This tracks multi-agent orchestration stages — it does NOT execute a browser automation playbook. To run a playbook use `playbook_run`.',
         category: 'workflow',
         inputSchema: {
             type: 'object',
@@ -650,5 +650,58 @@ export const workflowTools = [
             return { action, error: 'Unknown action' };
         },
     },
+    {
+        name: 'playbook_run',
+        description: 'Run a browser automation playbook (JSON file with browser/service/HTTP nodes) via @monoes/monobrowse. Executes the full playbook engine with all handlers: browser CDP nodes (browser.open, browser.click, etc.), service nodes (gmail, github, google_drive, google_sheets), and builtins (action.http, action.log, action.save_file, action.gemini_image).',
+        category: 'workflow',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Absolute or CWD-relative path to a playbook JSON file' },
+                params: {
+                    type: 'object',
+                    description: 'Key/value pairs substituted as {{params.key}} in playbook node configs',
+                    additionalProperties: { type: 'string' },
+                },
+                port: { type: 'number', description: 'CDP port for browser automation (default 9222)' },
+                timeoutSeconds: { type: 'number', description: 'Max run duration in seconds (default 300)' },
+            },
+            required: ['file'],
+        },
+        handler: async (input) => {
+            const filePath = input.file;
+            if (typeof filePath !== 'string' || !filePath)
+                throw new Error('playbook_run: file is required');
+            if (filePath.startsWith('-'))
+                throw new Error('playbook_run: file path must not start with "-"');
+            const { resolve } = await import('node:path');
+            const absPath = resolve(process.cwd(), filePath);
+            const timeoutMs = (input.timeoutSeconds ?? 300) * 1000;
+            const rawParams = input.params ?? {};
+            // Sanitize params — string values only
+            const params = Object.fromEntries(Object.entries(rawParams).map(([k, v]) => [k, String(v)]));
+            if (input.port !== undefined) {
+                process.env['GEMINI_CDP_PORT'] = String(input.port);
+            }
+            const { readPlaybook, runPlaybook, createDefaultHandlers } = await import('@monoes/monobrowse');
+            const def = await readPlaybook(absPath);
+            const record = await runPlaybook(def, {
+                handlers: createDefaultHandlers(),
+                signal: AbortSignal.timeout(timeoutMs),
+                params,
+            });
+            return {
+                playbookId: record.playbookId,
+                playbookName: record.playbookName,
+                status: record.status,
+                itemsProcessed: record.itemsProcessed,
+                itemsTotal: record.itemsTotal,
+                durationMs: record.completedAt && record.startedAt
+                    ? record.completedAt - record.startedAt
+                    : undefined,
+                error: record.error,
+            };
+        },
+    },
 ];
 //# sourceMappingURL=workflow-tools.js.map

package/packages/@monomind/cli/dist/src/memory/embedding-operations.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Embedding Operations
+ * ONNX model loading, embedding generation, and hash-based fallback.
+ * Extracted from memory-initializer.ts (ARCH-4)
+ *
+ * @module v1/cli/embedding-operations
+ */
+/**
+ * Lazy load ONNX embedding model
+ * Only loads when first embedding is requested
+ */
+export declare function loadEmbeddingModel(options?: {
+    modelPath?: string;
+    verbose?: boolean;
+}): Promise<{
+    success: boolean;
+    dimensions: number;
+    modelName: string;
+    loadTime?: number;
+    error?: string;
+}>;
+/**
+ * Generate real embedding for text
+ * Uses ONNX model if available, falls back to deterministic hash
+ */
+export declare function generateEmbedding(text: string): Promise<{
+    embedding: number[];
+    dimensions: number;
+    model: string;
+}>;
+/**
+ * Generate embeddings for multiple texts
+ * Uses parallel execution for API-based providers (2-4x faster)
+ * Note: Local ONNX inference is CPU-bound, so parallelism has limited benefit
+ *
+ * @param texts - Array of texts to embed
+ * @param options - Batch options
+ * @returns Array of embedding results with timing info
+ */
+export declare function generateBatchEmbeddings(texts: string[], options?: {
+    concurrency?: number;
+    onProgress?: (completed: number, total: number) => void;
+}): Promise<{
+    results: Array<{
+        text: string;
+        embedding: number[];
+        dimensions: number;
+        model: string;
+    }>;
+    totalTime: number;
+    avgTime: number;
+}>;
+/**
+ * Generate deterministic hash-based embedding
+ * Not semantic, but deterministic and useful for testing
+ */
+export declare function generateHashEmbedding(text: string, dimensions: number): number[];
+//# sourceMappingURL=embedding-operations.d.ts.map

package/packages/@monomind/cli/dist/src/memory/embedding-operations.js

@@ -0,0 +1,299 @@
+/**
+ * Embedding Operations
+ * ONNX model loading, embedding generation, and hash-based fallback.
+ * Extracted from memory-initializer.ts (ARCH-4)
+ *
+ * @module v1/cli/embedding-operations
+ */
+// ADR-053: Lazy import of AgentDB v1 bridge
+let _bridge;
+async function getBridge() {
+    if (_bridge === null)
+        return null;
+    if (_bridge)
+        return _bridge;
+    try {
+        _bridge = await import('./memory-bridge.js');
+        return _bridge;
+    }
+    catch {
+        _bridge = null;
+        return null;
+    }
+}
+let embeddingModelState = null;
+/**
+ * Lazy load ONNX embedding model
+ * Only loads when first embedding is requested
+ */
+export async function loadEmbeddingModel(options) {
+    const { verbose = false } = options || {};
+    const startTime = Date.now();
+    // Already loaded
+    if (embeddingModelState?.loaded) {
+        return {
+            success: true,
+            dimensions: embeddingModelState.dimensions,
+            modelName: 'cached',
+            loadTime: 0
+        };
+    }
+    // ADR-053: Try AgentDB v1 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeLoadEmbeddingModel();
+        if (bridgeResult && bridgeResult.success) {
+            // Mark local state as loaded too so subsequent calls use cache
+            embeddingModelState = {
+                loaded: true,
+                model: null, // Bridge handles embedding
+                tokenizer: null,
+                dimensions: bridgeResult.dimensions
+            };
+            return bridgeResult;
+        }
+    }
+    try {
+        // Try to import @xenova/transformers for ONNX embeddings
+        const transformers = await import('@xenova/transformers').catch(() => null);
+        if (transformers) {
+            if (verbose) {
+                console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
+            }
+            // Use small, fast model for local embeddings
+            const { pipeline } = transformers;
+            const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+            embeddingModelState = {
+                loaded: true,
+                model: embedder,
+                tokenizer: null,
+                dimensions: 384 // MiniLM-L6 produces 384-dim vectors
+            };
+            return {
+                success: true,
+                dimensions: 384,
+                modelName: 'Xenova/all-MiniLM-L6-v2',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // Fallback: Check for agentic-flow ReasoningBank embeddings (v1)
+        const reasoningBank = await import('agentic-flow/reasoningbank').catch(() => null);
+        if (reasoningBank?.computeEmbedding) {
+            if (verbose) {
+                console.log('Loading agentic-flow ReasoningBank embedding model...');
+            }
+            embeddingModelState = {
+                loaded: true,
+                model: { embed: reasoningBank.computeEmbedding },
+                tokenizer: null,
+                dimensions: 768
+            };
+            return {
+                success: true,
+                dimensions: 768,
+                modelName: 'agentic-flow/reasoningbank',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // Fallback: Check for monovector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
+        // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
+        // Note: isReady() returns false until first embed() call (lazy init), so we
+        // skip the isReady() gate and verify with a probe embed instead.
+        const monovector = await import('monovector').catch(() => null);
+        if (monovector?.initOnnxEmbedder) {
+            try {
+                await monovector.initOnnxEmbedder();
+                // Fallback: OptimizedOnnxEmbedder (raw ONNX, lazy-inits on first embed)
+                const onnxEmb = monovector.getOptimizedOnnxEmbedder?.();
+                if (onnxEmb?.embed) {
+                    // Probe embed to trigger lazy ONNX init and verify it works
+                    const probe = await onnxEmb.embed('test');
+                    if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some((v) => v !== 0) : true)) {
+                        if (verbose) {
+                            console.log(`Loading monovector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
+                        }
+                        embeddingModelState = {
+                            loaded: true,
+                            model: (text) => onnxEmb.embed(text),
+                            tokenizer: null,
+                            dimensions: probe.length || 384
+                        };
+                        return {
+                            success: true,
+                            dimensions: probe.length || 384,
+                            modelName: 'monovector/onnx',
+                            loadTime: Date.now() - startTime
+                        };
+                    }
+                }
+            }
+            catch {
+                // monovector ONNX init failed, continue to next fallback
+            }
+        }
+        // Legacy fallback: Check for agentic-flow core embeddings
+        const agenticFlow = await import('agentic-flow').catch(() => null);
+        if (agenticFlow && agenticFlow.embeddings) {
+            if (verbose) {
+                console.log('Loading agentic-flow embedding model...');
+            }
+            embeddingModelState = {
+                loaded: true,
+                model: agenticFlow.embeddings,
+                tokenizer: null,
+                dimensions: 768
+            };
+            return {
+                success: true,
+                dimensions: 768,
+                modelName: 'agentic-flow',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // No ONNX model available - use fallback
+        embeddingModelState = {
+            loaded: true,
+            model: null, // Will use simple hash-based fallback
+            tokenizer: null,
+            dimensions: 128 // Smaller fallback dimensions
+        };
+        return {
+            success: true,
+            dimensions: 128,
+            modelName: 'hash-fallback',
+            loadTime: Date.now() - startTime
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            dimensions: 0,
+            modelName: 'none',
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Generate real embedding for text
+ * Uses ONNX model if available, falls back to deterministic hash
+ */
+export async function generateEmbedding(text) {
+    // Cap input text — caller may pass arbitrarily large content. Without this
+    // cap, the hash-fallback below burns O(text.length × dimension) sin() calls
+    // per call, and ONNX tokenization can saturate memory on multi-MB inputs.
+    if (typeof text !== 'string')
+        text = String(text ?? '');
+    if (text.length > 16 * 1024)
+        text = text.slice(0, 16 * 1024);
+    // ADR-053: Try AgentDB v1 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGenerateEmbedding(text);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Ensure model is loaded
+    if (!embeddingModelState?.loaded) {
+        await loadEmbeddingModel();
+    }
+    const state = embeddingModelState;
+    // Use ONNX model if available
+    if (state.model && typeof state.model === 'function') {
+        try {
+            const output = await state.model(text, { pooling: 'mean', normalize: true });
+            // Handle both @xenova/transformers (output.data) and monovector (plain array) formats
+            const embedding = output?.data
+                ? Array.from(output.data)
+                : Array.isArray(output) ? output : null;
+            if (embedding) {
+                return {
+                    embedding,
+                    dimensions: embedding.length,
+                    model: 'onnx'
+                };
+            }
+        }
+        catch {
+            // Fall through to fallback
+        }
+    }
+    // Deterministic hash-based fallback (for testing/demo without ONNX)
+    const embedding = generateHashEmbedding(text, state.dimensions);
+    return {
+        embedding,
+        dimensions: state.dimensions,
+        model: 'hash-fallback'
+    };
+}
+/**
+ * Generate embeddings for multiple texts
+ * Uses parallel execution for API-based providers (2-4x faster)
+ * Note: Local ONNX inference is CPU-bound, so parallelism has limited benefit
+ *
+ * @param texts - Array of texts to embed
+ * @param options - Batch options
+ * @returns Array of embedding results with timing info
+ */
+export async function generateBatchEmbeddings(texts, options) {
+    const { concurrency = texts.length, onProgress } = options || {};
+    const startTime = Date.now();
+    // Ensure model is loaded first (prevents cold start in parallel)
+    if (!embeddingModelState?.loaded) {
+        await loadEmbeddingModel();
+    }
+    // Process in parallel with optional concurrency limit
+    if (concurrency >= texts.length) {
+        // Full parallelism
+        const embeddings = await Promise.all(texts.map(async (text, i) => {
+            const result = await generateEmbedding(text);
+            onProgress?.(i + 1, texts.length);
+            return { text, ...result };
+        }));
+        const totalTime = Date.now() - startTime;
+        return {
+            results: embeddings,
+            totalTime,
+            avgTime: totalTime / texts.length
+        };
+    }
+    // Limited concurrency using chunking
+    const results = [];
+    let completed = 0;
+    for (let i = 0; i < texts.length; i += concurrency) {
+        const chunk = texts.slice(i, i + concurrency);
+        const chunkResults = await Promise.all(chunk.map(async (text) => {
+            const result = await generateEmbedding(text);
+            completed++;
+            onProgress?.(completed, texts.length);
+            return { text, ...result };
+        }));
+        results.push(...chunkResults);
+    }
+    const totalTime = Date.now() - startTime;
+    return {
+        results,
+        totalTime,
+        avgTime: totalTime / texts.length
+    };
+}
+/**
+ * Generate deterministic hash-based embedding
+ * Not semantic, but deterministic and useful for testing
+ */
+export function generateHashEmbedding(text, dimensions) {
+    const embedding = new Array(dimensions).fill(0);
+    // Simple hash-based approach for reproducibility
+    const words = text.toLowerCase().split(/\s+/);
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        for (let j = 0; j < word.length; j++) {
+            const charCode = word.charCodeAt(j);
+            const idx = (charCode * (i + 1) * (j + 1)) % dimensions;
+            embedding[idx] += Math.sin(charCode * 0.1) * 0.1;
+        }
+    }
+    // Normalize to unit vector
+    const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0)) || 1;
+    return embedding.map(v => v / magnitude);
+}
+//# sourceMappingURL=embedding-operations.js.map

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.js

@@ -49,6 +49,12 @@ export class EWCConsolidator {
     globalFisher = [];
     consolidationHistory = [];
     initialized = false;
+    /** Dirty flag: true when in-memory state diverges from disk */
+    dirty = false;
+    /** Pending debounced write timer */
+    saveTimer = null;
+    /** Debounce window for disk writes (ms) */
+    static SAVE_DEBOUNCE_MS = 2_000;
     constructor(config) {
         this.config = { ...DEFAULT_EWC_CONFIG, ...config };
         this.globalFisher = new Array(this.config.dimensions).fill(0);
@@ -207,8 +213,8 @@ export class EWCConsolidator {
             if (this.consolidationHistory.length > 100) {
                 this.consolidationHistory = this.consolidationHistory.slice(-100);
             }
-            // Persist to disk
-            this.saveToDisk();
+            // Schedule debounced disk flush
+            this.scheduleSave();
             result.success = true;
             result.duration = performance.now() - startTime;
             return result;
@@ -322,6 +328,8 @@ export class EWCConsolidator {
                 this.globalFisher[i] = (1 - decay) * this.globalFisher[i] + decay * gradients[i] * gradients[i];
             }
         }
+        // Schedule debounced flush so importance/Fisher updates are persisted
+        this.scheduleSave();
     }
     /**
      * Get pattern weights by ID
@@ -391,7 +399,7 @@ export class EWCConsolidator {
         for (let i = 0; i < this.config.dimensions; i++) {
             this.globalFisher[i] = alpha * this.globalFisher[i] + (1 - alpha) * currentFisher[i];
         }
-        this.saveToDisk();
+        this.scheduleSave();
     }
     /**
      * Compute consolidation penalty for a proposed confidence update.
@@ -416,6 +424,12 @@ export class EWCConsolidator {
      * Clear all patterns and history (full reset)
      */
     clear() {
+        // Cancel any pending debounced write before clearing
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        this.dirty = false;
         this.patterns.clear();
         this.gradientHistory = [];
         this.globalFisher = new Array(this.config.dimensions).fill(0);
@@ -485,6 +499,26 @@ export class EWCConsolidator {
             this.patterns.delete(sortedPatterns[i].id);
         }
     }
+    /**
+     * Schedule a debounced disk flush.
+     * Multiple calls within SAVE_DEBOUNCE_MS coalesce into one write,
+     * preventing blocking I/O on every consolidation or gradient event.
+     */
+    scheduleSave() {
+        this.dirty = true;
+        if (this.saveTimer)
+            return; // already scheduled
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            if (this.dirty) {
+                this.dirty = false;
+                this.saveToDisk();
+            }
+        }, EWCConsolidator.SAVE_DEBOUNCE_MS);
+        // Allow the process to exit without waiting for the timer
+        if (this.saveTimer.unref)
+            this.saveTimer.unref();
+    }
     /**
      * Save state to disk
      */