monomind 1.18.13 → 1.19.0

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -59,8 +59,7 @@ function getStatsPath() {
 const DEFAULT_SONA_CONFIG = {
     instantLoopEnabled: true,
     backgroundLoopEnabled: false,
-    loraLearningRate: 0.001,
-    loraRank: 8,
+    confidenceLearningRate: 0.001,
     ewcLambda: 0.4,
     maxTrajectorySize: 100,
     patternThreshold: 0.7,
@@ -148,7 +147,7 @@ class LocalSonaCoordinator {
         }
     }
     /**
-     * End the current trajectory with a verdict and apply RL updates.
+     * End the current trajectory with a verdict and apply confidence updates.
      * Reward mapping: success=1.0, partial=0.5, failure=-0.5
      *
      * For successful/partial trajectories, boosts confidence of similar patterns
@@ -198,10 +197,10 @@ class LocalSonaCoordinator {
     }
     /**
      * Distill learning from recent successful trajectories.
-     * Applies LoRA-style confidence updates and integrates EWC++ consolidation.
+     * Applies incremental confidence updates and integrates EWC consolidation.
      *
      * For each successful trajectory step with high confidence,
-     * increases the pattern's stored confidence by loraLearningRate * reward.
+     * increases the pattern's stored confidence by confidenceLearningRate * reward.
      * Before applying updates, checks EWC penalty to prevent catastrophic forgetting.
      */
     async distillLearning(bank) {
@@ -249,13 +248,13 @@ class LocalSonaCoordinator {
                     // Check EWC penalty before applying update
                     if (ewcConsolidator) {
                         const oldWeights = [oldConfidence];
-                        const proposedConfidence = Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward);
+                        const proposedConfidence = Math.min(1.0, oldConfidence + this.config.confidenceLearningRate * reward);
                         const newWeights = [proposedConfidence];
                         const penalty = ewcConsolidator.getPenalty(oldWeights, newWeights);
                         totalEwcPenalty += penalty;
                         // If penalty is too high, reduce the update magnitude
                         if (penalty > this.config.ewcLambda) {
-                            const dampedDelta = (this.config.loraLearningRate * reward) / (1 + penalty);
+                            const dampedDelta = (this.config.confidenceLearningRate * reward) / (1 + penalty);
                             pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + dampedDelta));
                         }
                         else {
@@ -263,8 +262,8 @@ class LocalSonaCoordinator {
                         }
                     }
                     else {
-                        // No EWC: apply full LoRA update
-                        pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward));
+                        // No consolidation guard available: apply the full confidence update
+                        pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + this.config.confidenceLearningRate * reward));
                     }
                     pattern.lastUsedAt = Date.now();
                     patternsDistilled++;
@@ -612,7 +611,7 @@ async function _doInitializeIntelligence(config) {
         });
         // Load persisted stats if available
         loadPersistedStats();
-        // Seed neural learned patterns from @monomind/neural's LearningBridge flush.
+        // Seed neural learned patterns from pattern store.
         // This is the A→B bridge reader: connects the automatic learning loop to routing.
         const neuralPatternsPath = join(getDataDir(), 'patterns.json');
         if (existsSync(neuralPatternsPath) && statSync(neuralPatternsPath).size <= 50 * 1024 * 1024) {
@@ -756,7 +755,7 @@ export async function recordStep(step) {
             metadata: step.metadata,
             timestamp: step.timestamp || Date.now()
         });
-        // Add to current trajectory for RL tracking
+        // Add to current trajectory for outcome tracking
         const stepWithEmbedding = { ...step, embedding };
         sonaCoordinator.addTrajectoryStep(stepWithEmbedding);
         // Store in ReasoningBank for retrieval
@@ -770,7 +769,7 @@ export async function recordStep(step) {
                 metadata: step.metadata
             });
         }
-        // When a 'result' step arrives, end the trajectory and run RL loop
+        // When a 'result' step arrives, end the trajectory and run the confidence-update loop
         if (step.type === 'result' && reasoningBank) {
             // Determine verdict from metadata or default to 'partial'
             const verdict = step.metadata?.verdict || 'partial';
@@ -801,7 +800,7 @@ export async function recordTrajectory(steps, verdict) {
             verdict,
             timestamp: Date.now()
         });
-        // Apply RL: update pattern confidences based on verdict
+        // Update pattern confidences based on verdict
         if (reasoningBank) {
             // Load steps into the coordinator for endTrajectory processing
             for (const step of steps) {
@@ -904,8 +903,8 @@ export function getReasoningBank() {
     return reasoningBank;
 }
 /**
- * End the current trajectory with a verdict and apply RL updates.
- * This is the public API for the SONA RL loop.
+ * End the current trajectory with a verdict and apply confidence updates.
+ * This is the public API for the SONA feedback loop.
  *
  * @param verdict - 'success' (reward=1.0), 'partial' (0.5), or 'failure' (-0.5)
  * @returns Update statistics or null if not initialized
@@ -928,7 +927,7 @@ export async function endTrajectoryWithVerdict(verdict) {
 }
 /**
  * Distill learning from recent successful trajectories.
- * Applies LoRA-style confidence updates with EWC++ consolidation protection.
+ * Applies incremental confidence updates with EWC consolidation protection.
  *
  * @returns Distillation statistics or null if not initialized
  */

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

@@ -26,6 +26,7 @@ export declare function bridgeStoreEntry(options: {
     guarded?: boolean;
     cached?: boolean;
     attested?: boolean;
+    duplicate?: boolean;
     error?: string;
 } | null>;
 export declare function bridgeSearchEntries(options: {

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

@@ -88,6 +88,25 @@ function getDbPath(customPath) {
         return resolved;
     return defaultDir;
 }
+function getAutomemConfig() {
+    const defaults = { dedupThreshold: 0.85, staleDays: 7 };
+    try {
+        const configPath = path.join(process.cwd(), '.monomind', 'automem-config.json');
+        if (!fs.existsSync(configPath))
+            return defaults;
+        const stat = fs.statSync(configPath);
+        if (stat.size > 64 * 1024)
+            return defaults;
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return {
+            dedupThreshold: typeof config?.scaffold?.dedupThreshold === 'number' ? config.scaffold.dedupThreshold : defaults.dedupThreshold,
+            staleDays: typeof config?.scaffold?.staleDays === 'number' ? config.scaffold.staleDays : defaults.staleDays,
+        };
+    }
+    catch {
+        return defaults;
+    }
+}
 function generateId(prefix) {
     return `${prefix}_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
 }
@@ -212,6 +231,17 @@ export async function bridgeStoreEntry(options) {
             }
             catch { /* non-fatal */ }
         }
+        // Dedup gate: skip if a near-duplicate already exists
+        const automemCfg = getAutomemConfig();
+        if (embedding && !options.upsert) {
+            try {
+                const similar = await backend.search(embedding, { k: 1, threshold: automemCfg.dedupThreshold });
+                if (similar.length > 0 && similar[0].score >= automemCfg.dedupThreshold) {
+                    return { success: true, id: similar[0].entry.id, duplicate: true };
+                }
+            }
+            catch { /* non-fatal — store anyway */ }
+        }
         await backend.store(entry);
         return { success: true, id, embedding: embeddingInfo };
     }
@@ -245,6 +275,7 @@ export async function bridgeSearchEntries(options) {
                     score: r.score,
                     namespace: r.entry.namespace,
                     provenance: `semantic:${r.score.toFixed(3)}`,
+                    _createdAt: r.entry.createdAt || 0,
                 }));
                 searchMethod = 'semantic';
             }
@@ -269,9 +300,15 @@ export async function bridgeSearchEntries(options) {
                 score: 0.5,
                 namespace: e.namespace,
                 provenance: 'keyword',
+                _createdAt: e.createdAt || 0,
             }));
             searchMethod = 'keyword';
         }
+        // Filter stale entries based on automem config
+        const { staleDays } = getAutomemConfig();
+        const staleCutoff = Date.now() - staleDays * 86400000;
+        results = results.filter((r) => !r._createdAt || r._createdAt > staleCutoff);
+        results.forEach((r) => delete r._createdAt);
         return {
             success: true,
             results,

package/packages/@monomind/cli/dist/src/services/worker-daemon.d.ts

@@ -7,7 +7,9 @@
  * - audit: Security analysis (10 min interval)
  * - optimize: Performance optimization (15 min interval)
  * - consolidate: Memory consolidation (30 min interval)
- * - testgaps: Test coverage analysis (20 min interval)
+ * - testgaps, predict, document, refactor, preload: no local-mode
+ *   implementation — real work only happens in headless mode via
+ *   HeadlessWorkerExecutor (Claude Code CLI required)
  */
 import { EventEmitter } from 'events';
 import { HeadlessWorkerExecutor } from './headless-worker-executor.js';
@@ -183,26 +185,10 @@ export declare class WorkerDaemon extends EventEmitter {
      */
     private runOptimizeWorkerLocal;
     private runConsolidateWorker;
-    /**
-     * Local testgaps worker (fallback when headless unavailable)
-     */
-    private runTestGapsWorkerLocal;
-    /**
-     * Local predict worker (fallback when headless unavailable)
-     */
-    private runPredictWorkerLocal;
-    /**
-     * Local document worker (fallback when headless unavailable)
-     */
-    private runDocumentWorkerLocal;
     /**
      * Local ultralearn worker (fallback when headless unavailable)
      */
     private runUltralearnWorkerLocal;
-    /**
-     * Local refactor worker (fallback when headless unavailable)
-     */
-    private runRefactorWorkerLocal;
     /**
      * Local deepdive worker (fallback when headless unavailable)
      */
@@ -211,10 +197,6 @@ export declare class WorkerDaemon extends EventEmitter {
      * Local benchmark worker
      */
     private runBenchmarkWorkerLocal;
-    /**
-     * Local preload worker
-     */
-    private runPreloadWorkerLocal;
     /**
      * Manually trigger a worker
      */

package/packages/@monomind/cli/dist/src/services/worker-daemon.js

@@ -7,7 +7,9 @@
  * - audit: Security analysis (10 min interval)
  * - optimize: Performance optimization (15 min interval)
  * - consolidate: Memory consolidation (30 min interval)
- * - testgaps: Test coverage analysis (20 min interval)
+ * - testgaps, predict, document, refactor, preload: no local-mode
+ *   implementation — real work only happens in headless mode via
+ *   HeadlessWorkerExecutor (Claude Code CLI required)
  */
 import { EventEmitter } from 'events';
 import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync, statSync } from 'fs';
@@ -723,22 +725,23 @@ export class WorkerDaemon extends EventEmitter {
                 return this.runOptimizeWorkerLocal();
             case 'consolidate':
                 return this.runConsolidateWorker();
-            case 'testgaps':
-                return this.runTestGapsWorkerLocal();
-            case 'predict':
-                return this.runPredictWorkerLocal();
-            case 'document':
-                return this.runDocumentWorkerLocal();
             case 'ultralearn':
                 return this.runUltralearnWorkerLocal();
-            case 'refactor':
-                return this.runRefactorWorkerLocal();
             case 'deepdive':
                 return this.runDeepdiveWorkerLocal();
             case 'benchmark':
                 return this.runBenchmarkWorkerLocal();
+            // testgaps/predict/document/refactor/preload have no real local-mode
+            // implementation — they only do real work in headless mode (see
+            // HeadlessWorkerExecutor). Without Claude Code CLI available there is
+            // nothing meaningful to run locally, so report that plainly instead of
+            // faking a result with hardcoded empty JSON (monolean).
+            case 'testgaps':
+            case 'predict':
+            case 'document':
+            case 'refactor':
             case 'preload':
-                return this.runPreloadWorkerLocal();
+                return { mode: 'local', note: 'Install Claude Code CLI for AI-powered analysis — no local implementation exists for this worker' };
             default:
                 return { status: 'unknown worker type', mode: 'local' };
         }
@@ -991,53 +994,6 @@ export class WorkerDaemon extends EventEmitter {
         renameSync(consolidateFileTmp, consolidateFile);
         return result;
     }
-    /**
-     * Local testgaps worker (fallback when headless unavailable)
-     */
-    async runTestGapsWorkerLocal() {
-        // Check for test coverage gaps
-        const testGapsFile = join(this.projectRoot, '.monomind', 'metrics', 'test-gaps.json');
-        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const result = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            hasTestDir: existsSync(join(this.projectRoot, 'tests')) || existsSync(join(this.projectRoot, '__tests__')),
-            estimatedCoverage: 'unknown',
-            gaps: [],
-            note: 'Install Claude Code CLI for AI-powered test gap analysis',
-        };
-        const testGapsFileTmp = testGapsFile + '.tmp';
-        writeFileSync(testGapsFileTmp, JSON.stringify(result, null, 2));
-        renameSync(testGapsFileTmp, testGapsFile);
-        return result;
-    }
-    /**
-     * Local predict worker (fallback when headless unavailable)
-     */
-    async runPredictWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            predictions: [],
-            preloaded: [],
-            note: 'Install Claude Code CLI for AI-powered predictions',
-        };
-    }
-    /**
-     * Local document worker (fallback when headless unavailable)
-     */
-    async runDocumentWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            filesDocumented: 0,
-            suggestedDocs: [],
-            note: 'Install Claude Code CLI for AI-powered documentation generation',
-        };
-    }
     /**
      * Local ultralearn worker (fallback when headless unavailable)
      */
@@ -1132,18 +1088,6 @@ export class WorkerDaemon extends EventEmitter {
         catch { /* monograph unavailable — return minimal result */ }
         return result;
     }
-    /**
-     * Local refactor worker (fallback when headless unavailable)
-     */
-    async runRefactorWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            suggestions: [],
-            duplicatesFound: 0,
-            note: 'Install Claude Code CLI for AI-powered refactoring suggestions',
-        };
-    }
     /**
      * Local deepdive worker (fallback when headless unavailable)
      */
@@ -1272,17 +1216,6 @@ export class WorkerDaemon extends EventEmitter {
         renameSync(benchmarkFileTmp, benchmarkFile);
         return result;
     }
-    /**
-     * Local preload worker
-     */
-    async runPreloadWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            resourcesPreloaded: 0,
-            cacheStatus: 'active',
-        };
-    }
     /**
      * Manually trigger a worker
      */

package/packages/@monomind/cli/dist/src/suggest.js

@@ -125,16 +125,11 @@ export const COMMON_TYPOS = {
     'hive': 'hive-mind',
     'hivemind': 'hive-mind',
     'hive_mind': 'hive-mind',
-    'neurl': 'neural',
-    'nueral': 'neural',
     'securty': 'security',
     'sec': 'security',
     'perf': 'performance',
     'performace': 'performance',
     'provider': 'providers',
-    'dep': 'deployment',
-    'depoly': 'deployment',
-    'deploy': 'deployment',
     'claim': 'claims',
     'embed': 'embeddings',
     'embeding': 'embeddings',

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.18.13",
+  "version": "1.19.0",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",