monomind 1.18.13 → 1.19.0

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

@@ -1,15 +1,9 @@
 /**
- * Neural MCP Tools for CLI
+ * Pattern Store MCP Tools
  *
- * V2 Compatibility - Neural network and ML tools
- *
- * ✅ HYBRID Implementation:
- * - Uses monovector ONNX embeddings when available
- * - Falls back to deterministic hash-based embeddings otherwise
- * - Pattern storage and search with cosine similarity (real math in all tiers)
- * - Training stores patterns as searchable embeddings (not simulated)
- *
- * Note: The lean build has no neural training. The full loop lives on monoes-full-loop.
+ * Embed text as vectors, store patterns, search by cosine similarity.
+ * Uses monovector ONNX embeddings when available, deterministic hash fallback otherwise.
+ * Tools are registered under the "neural" namespace for backwards compatibility.
  */
 import { getProjectCwd } from './types.js';
 import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'node:fs';
@@ -141,16 +135,16 @@ function cosineSimilarity(a, b) {
 export const neuralTools = [
     {
         name: 'neural_train',
-        description: 'Train a neural model',
+        description: 'Embed and store patterns for similarity search',
         category: 'neural',
         inputSchema: {
             type: 'object',
             properties: {
-                modelId: { type: 'string', description: 'Model ID to train' },
-                modelType: { type: 'string', enum: ['moe', 'transformer', 'classifier', 'embedding'], description: 'Model type' },
-                epochs: { type: 'number', description: 'Number of training epochs' },
-                learningRate: { type: 'number', description: 'Learning rate' },
-                data: { type: 'object', description: 'Training data' },
+                modelId: { type: 'string', description: 'Store ID (groups related patterns)' },
+                modelType: { type: 'string', enum: ['pattern', 'embedding'], description: 'Store type' },
+                epochs: { type: 'number', description: 'Ignored (kept for backwards compatibility)' },
+                learningRate: { type: 'number', description: 'Ignored (kept for backwards compatibility)' },
+                data: { type: 'object', description: 'Data to embed and store (array of strings or {text/content/label} objects)' },
             },
             required: ['modelType'],
         },
@@ -174,30 +168,21 @@ export const neuralTools = [
             if (Object.keys(store.models ?? {}).length >= MAX_MODELS) {
                 return { success: false, error: `Model store full (max ${MAX_MODELS}). Delete old models first.` };
             }
-            // Runtime-validate modelType against the allowed enum. The JSON schema
-            // declares an enum but callers that bypass schema validation (e.g. direct
-            // MCP calls) can pass arbitrary strings, which would be stored verbatim.
-            const VALID_MODEL_TYPES = new Set(['moe', 'transformer', 'classifier', 'embedding']);
+            const VALID_MODEL_TYPES = new Set(['pattern', 'embedding']);
             const rawModelType = input.modelType;
             if (!rawModelType || !VALID_MODEL_TYPES.has(rawModelType)) {
-                return { success: false, error: `Invalid modelType "${rawModelType}". Must be one of: moe, transformer, classifier, embedding` };
+                return { success: false, error: `Invalid modelType "${rawModelType}". Must be one of: pattern, embedding` };
             }
             const modelType = rawModelType;
-            // Cap epochs to prevent storing absurdly large numbers in the JSON store.
-            const MAX_EPOCHS = 10000;
-            const rawEpochs = typeof input.epochs === 'number' && Number.isFinite(input.epochs) ? input.epochs : 10;
-            const epochs = Math.max(1, Math.min(Math.floor(rawEpochs), MAX_EPOCHS));
+            const epochs = 1;
             const model = {
                 id: modelId,
-                name: `${modelType}-model`,
+                name: `${modelType}-store`,
                 type: modelType,
-                status: 'training',
-                accuracy: 0,
+                status: 'indexing',
+                patternsStored: 0,
                 epochs,
-                config: {
-                    learningRate: input.learningRate || 0.001,
-                    batchSize: 32,
-                },
+                config: {},
             };
             store.models[modelId] = model;
             saveNeuralStore(store);
@@ -241,7 +226,7 @@ export const neuralTools = [
                 }
             }
             model.status = 'ready';
-            model.accuracy = patternsStored > 0 ? 1.0 : 0; // accuracy = data stored, not simulated
+            model.patternsStored = patternsStored;
             model.trainedAt = new Date().toISOString();
             saveNeuralStore(store);
             // Mirror patterns to patterns.json so CLI commands (neural patterns list,
@@ -294,14 +279,14 @@ export const neuralTools = [
     },
     {
         name: 'neural_predict',
-        description: 'Make predictions using a neural model',
+        description: 'Find similar patterns by cosine similarity',
         category: 'neural',
         inputSchema: {
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Model ID to use' },
-                input: { type: 'string', description: 'Input text or data' },
-                topK: { type: 'number', description: 'Number of top predictions' },
+                input: { type: 'string', description: 'Text to find similar patterns for' },
+                topK: { type: 'number', description: 'Number of top results to return' },
             },
             required: ['input'],
         },
@@ -330,9 +315,8 @@ export const neuralTools = [
             const startTime = performance.now();
             const embedding = await generateEmbedding(inputText, 384);
             const latency = Math.round(performance.now() - startTime);
-            // Search stored patterns via real cosine similarity.
-            // Merge MCP models.json patterns with CLI patterns.json so both training
-            // paths are visible from predict.
+            // Search stored patterns via cosine similarity.
+            // Merge MCP models.json patterns with CLI patterns.json.
             const MAX_SCAN = 10000;
             const EARLY_EXIT_THRESHOLD = 0.1;
             const mcpPatterns = Object.values(store.patterns);
@@ -525,7 +509,7 @@ export const neuralTools = [
     },
     {
         name: 'neural_compress',
-        description: 'Compress neural model or embeddings',
+        description: 'Compress pattern store (quantize, prune, or deduplicate)',
         category: 'neural',
         inputSchema: {
             type: 'object',
@@ -634,7 +618,7 @@ export const neuralTools = [
     },
     {
         name: 'neural_status',
-        description: 'Get neural system status',
+        description: 'Get pattern store status',
         category: 'neural',
         inputSchema: {
             type: 'object',
@@ -663,15 +647,11 @@ export const neuralTools = [
             const models = Object.values(store.models);
             const patterns = Object.values(store.patterns);
             return {
-                _realEmbeddings: !!realEmbeddings,
                 embeddingProvider: realEmbeddings ? embeddingServiceName : 'hash-based (deterministic)',
                 models: {
                     total: models.length,
                     ready: models.filter(m => m.status === 'ready').length,
-                    training: models.filter(m => m.status === 'training').length,
-                    avgAccuracy: models.length > 0
-                        ? models.reduce((sum, m) => sum + m.accuracy, 0) / models.length
-                        : 0,
+                    indexing: models.filter(m => m.status === 'indexing').length,
                 },
                 patterns: {
                     total: patterns.length,
@@ -679,20 +659,14 @@ export const neuralTools = [
                         acc[p.type] = (acc[p.type] || 0) + 1;
                         return acc;
                     }, {}),
-                    totalEmbeddingDims: patterns.length > 0 ? patterns[0].embedding.length : 384,
-                },
-                features: {
-                    hnsw: true,
-                    quantization: true,
-                    flashAttention: false,
-                    reasoningBank: true,
+                    embeddingDims: patterns.length > 0 ? patterns[0].embedding.length : 384,
                 },
             };
         },
     },
     {
         name: 'neural_optimize',
-        description: 'Optimize neural model performance',
+        description: 'Optimize pattern store (deduplicate, quantize, prune empty)',
         category: 'neural',
         inputSchema: {
             type: 'object',

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

@@ -640,24 +640,12 @@ export const performanceTools = [
                     _real: true,
                 },
                 latency: {
-                    current: 45,
-                    avg: 52,
-                    min: 15,
-                    max: 250,
-                    p50: 48,
-                    p95: 150,
-                    p99: 220,
-                    unit: 'ms',
+                    _note: 'No latency telemetry collected. Wire up real instrumentation to populate this section.',
+                    available: false,
                 },
                 throughput: {
-                    current: 1250,
-                    avg: 1100,
-                    min: 500,
-                    max: 2000,
-                    p50: 1050,
-                    p95: 1800,
-                    p99: 1950,
-                    unit: 'ops/s',
+                    _note: 'No throughput telemetry collected. Wire up real instrumentation to populate this section.',
+                    available: false,
                 },
             };
             if (metric === 'all') {
@@ -681,7 +669,7 @@ export const performanceTools = [
                 _real: ['cpu', 'memory'].includes(metric),
                 metric,
                 value: aggValue,
-                unit: selectedMetric.unit,
+                unit: 'unit' in selectedMetric ? selectedMetric.unit : undefined,
                 details: selectedMetric,
                 timestamp: new Date().toISOString(),
             };

package/packages/@monomind/cli/dist/src/mcp-tools/quality/coverage-analysis/prioritize-gaps.js

@@ -150,7 +150,7 @@ async function calculatePriorities(gaps, factors, weights, bridge) {
                 score,
                 weight: weights.complexity,
                 contribution,
-                details: `Cyclomatic complexity: ${Math.round(score * 20)}`,
+                details: `Estimated complexity (line-based proxy, not McCabe): ${Math.round(score * 20)}`,
             });
             totalScore += contribution;
         }
@@ -237,7 +237,7 @@ async function calculatePriorities(gaps, factors, weights, bridge) {
 }
 function calculateComplexityScore(gap) {
     const lines = gap.endLine - gap.startLine;
-    // Estimate cyclomatic complexity from line count
+    // Line-based proxy — not real McCabe cyclomatic complexity
     const estimatedComplexity = lines / 5;
     return Math.min(estimatedComplexity / 10, 1);
 }

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.d.ts

@@ -15,16 +15,16 @@ export declare const DetectSecretsInputSchema: z.ZodObject<{
     scanHistory: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     targetPath: string;
-    excludePatterns: string[];
     secretTypes: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
+    excludePatterns: string[];
     includeEntropy: boolean;
     entropyThreshold: number;
     verifySecrets: boolean;
     scanHistory: boolean;
 }, {
     targetPath: string;
-    excludePatterns?: string[] | undefined;
     secretTypes?: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
+    excludePatterns?: string[] | undefined;
     includeEntropy?: boolean | undefined;
     entropyThreshold?: number | undefined;
     verifySecrets?: boolean | undefined;
@@ -116,16 +116,16 @@ export declare const toolDefinition: {
         scanHistory: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         targetPath: string;
-        excludePatterns: string[];
         secretTypes: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
+        excludePatterns: string[];
         includeEntropy: boolean;
         entropyThreshold: number;
         verifySecrets: boolean;
         scanHistory: boolean;
     }, {
         targetPath: string;
-        excludePatterns?: string[] | undefined;
         secretTypes?: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
+        excludePatterns?: string[] | undefined;
         includeEntropy?: boolean | undefined;
         entropyThreshold?: number | undefined;
         verifySecrets?: boolean | undefined;

package/packages/@monomind/cli/dist/src/mcp-tools/quality-tools.d.ts

@@ -1,8 +1,13 @@
 /**
  * Quality Tools — built-in quality MCP tools
  *
- * Wraps all 16 tools for test generation, coverage, defect intelligence, security, chaos
- * (quality_*) and plain JSON Schema inputSchemas.
+ * Wraps 2 tools: coverage gap prioritization and secret detection.
+ *
+ * monolean: 14 tools were removed — their handlers fabricated results
+ * (hardcoded fake file coverage, Math.random()-driven projections/predictions,
+ * invented defect data, fake security scan findings, hardcoded compliance
+ * results) rather than performing real analysis. Only prioritize-gaps
+ * (salvageable) and detect-secrets (real) remain.
  */
 import type { MCPTool } from './types.js';
 export declare const qualityTools: MCPTool[];

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

@@ -1,25 +1,16 @@
 /**
  * Quality Tools — built-in quality MCP tools
  *
- * Wraps all 16 tools for test generation, coverage, defect intelligence, security, chaos
- * (quality_*) and plain JSON Schema inputSchemas.
+ * Wraps 2 tools: coverage gap prioritization and secret detection.
+ *
+ * monolean: 14 tools were removed — their handlers fabricated results
+ * (hardcoded fake file coverage, Math.random()-driven projections/predictions,
+ * invented defect data, fake security scan findings, hardcoded compliance
+ * results) rather than performing real analysis. Only prioritize-gaps
+ * (salvageable) and detect-secrets (real) remain.
  */
-import { handler as generateTestsHandler } from './quality/test-generation/generate-tests.js';
-import { handler as tddCycleHandler } from './quality/test-generation/tdd-cycle.js';
-import { handler as suggestTestsHandler } from './quality/test-generation/suggest-tests.js';
-import { handler as analyzeCoverageHandler } from './quality/coverage-analysis/analyze-coverage.js';
 import { handler as prioritizeGapsHandler } from './quality/coverage-analysis/prioritize-gaps.js';
-import { handler as trackTrendsHandler } from './quality/coverage-analysis/track-trends.js';
-import { handler as evaluateGateHandler } from './quality/quality-assessment/evaluate-quality-gate.js';
-import { handler as assessReadinessHandler } from './quality/quality-assessment/assess-readiness.js';
-import { handler as calculateRiskHandler } from './quality/quality-assessment/calculate-risk.js';
-import { handler as predictDefectsHandler } from './quality/defect-intelligence/predict-defects.js';
-import { handler as analyzeDefectHandler } from './quality/defect-intelligence/analyze-root-cause.js';
-import { handler as findSimilarDefectsHandler } from './quality/defect-intelligence/find-similar-defects.js';
-import { handler as securityScanHandler } from './quality/security-compliance/security-scan.js';
-import { handler as auditComplianceHandler } from './quality/security-compliance/audit-compliance.js';
 import { handler as detectSecretsHandler } from './quality/security-compliance/detect-secrets.js';
-import { handler as chaosInjectHandler } from './quality/chaos-resilience/chaos-inject.js';
 // monolean: minimal context shim — quality handlers call context.get() which
 // is optional; returning undefined is safe for all current handlers.
 const noopContext = { get: (_key) => undefined };
@@ -30,84 +21,6 @@ function wrap(handler) {
     };
 }
 export const qualityTools = [
-    {
-        name: 'quality_generate_tests',
-        description: 'Generate AI-powered tests for code. Supports unit, integration, e2e, property, mutation, and fuzz test types across multiple frameworks.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to test' },
-                testType: { type: 'string', enum: ['unit', 'integration', 'e2e', 'property', 'mutation', 'fuzz'] },
-                framework: { type: 'string', enum: ['vitest', 'jest', 'mocha', 'pytest', 'junit'] },
-                coverage: {
-                    type: 'object',
-                    properties: {
-                        target: { type: 'number' },
-                        focusGaps: { type: 'boolean' },
-                    },
-                },
-                style: { type: 'string', enum: ['tdd-london', 'tdd-chicago', 'bdd', 'example-based'] },
-                language: { type: 'string', enum: ['typescript', 'javascript', 'python', 'java', 'go', 'rust'] },
-                includeEdgeCases: { type: 'boolean' },
-                includeMocks: { type: 'boolean' },
-                maxTests: { type: 'number' },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(generateTestsHandler),
-    },
-    {
-        name: 'quality_tdd_cycle',
-        description: 'Run a TDD red-green-refactor cycle for a requirement. Creates failing test, minimal implementation, then refactors.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                requirement: { type: 'string', description: 'Requirement or feature to implement via TDD' },
-                targetPath: { type: 'string', description: 'Path to file/directory for implementation' },
-                framework: { type: 'string', enum: ['vitest', 'jest', 'mocha', 'pytest', 'junit'] },
-                language: { type: 'string', enum: ['typescript', 'javascript', 'python', 'java', 'go', 'rust'] },
-                style: { type: 'string', enum: ['tdd-london', 'tdd-chicago', 'bdd', 'example-based'] },
-            },
-            required: ['requirement', 'targetPath'],
-        },
-        handler: wrap(tddCycleHandler),
-    },
-    {
-        name: 'quality_suggest_tests',
-        description: 'Suggest tests to improve coverage for a given file or directory. Returns prioritized test suggestions.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to analyze' },
-                maxSuggestions: { type: 'number' },
-                focusAreas: { type: 'array', items: { type: 'string' } },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(suggestTestsHandler),
-    },
-    {
-        name: 'quality_analyze_coverage',
-        description: 'Analyze test coverage for a file or directory. Returns coverage metrics and identifies gaps.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to analyze' },
-                includeUncovered: { type: 'boolean' },
-                threshold: { type: 'number' },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(analyzeCoverageHandler),
-    },
     {
         name: 'quality_prioritize_gaps',
         description: 'Prioritize coverage gaps by risk and impact. Returns ordered list of gaps to address.',
@@ -124,151 +37,6 @@ export const qualityTools = [
         },
         handler: wrap(prioritizeGapsHandler),
     },
-    {
-        name: 'quality_track_trends',
-        description: 'Track coverage trends over time. Returns trend analysis and regression detection.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string' },
-                period: { type: 'string', enum: ['day', 'week', 'month'] },
-                metric: { type: 'string', enum: ['line', 'branch', 'function'] },
-            },
-            required: [],
-        },
-        handler: wrap(trackTrendsHandler),
-    },
-    {
-        name: 'quality_evaluate_gate',
-        description: 'Evaluate whether code passes quality gates (coverage thresholds, complexity, etc.).',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string' },
-                gates: { type: 'array', items: { type: 'object' } },
-                strict: { type: 'boolean' },
-            },
-            required: [],
-        },
-        handler: wrap(evaluateGateHandler),
-    },
-    {
-        name: 'quality_assess_readiness',
-        description: 'Assess code readiness for release. Checks quality gates, test coverage, and risk factors.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string' },
-                releaseType: { type: 'string', enum: ['major', 'minor', 'patch'] },
-                checkList: { type: 'array', items: { type: 'string' } },
-            },
-            required: [],
-        },
-        handler: wrap(assessReadinessHandler),
-    },
-    {
-        name: 'quality_calculate_risk',
-        description: 'Calculate risk score for a file or change. Returns risk metrics and recommendations.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to assess' },
-                includeHistory: { type: 'boolean' },
-                riskFactors: { type: 'array', items: { type: 'string' } },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(calculateRiskHandler),
-    },
-    {
-        name: 'quality_predict_defects',
-        description: 'Predict defect-prone areas in code using static analysis and historical patterns.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to analyze' },
-                confidence: { type: 'number' },
-                maxPredictions: { type: 'number' },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(predictDefectsHandler),
-    },
-    {
-        name: 'quality_analyze_defect',
-        description: 'Analyze root cause of a defect. Returns causal chain, contributing factors, and fix recommendations.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                defect: { type: 'object', description: 'Defect description with title, description, stackTrace' },
-                codeContext: { type: 'string' },
-                includeFixSuggestions: { type: 'boolean' },
-            },
-            required: ['defect'],
-        },
-        handler: wrap(analyzeDefectHandler),
-    },
-    {
-        name: 'quality_find_similar_defects',
-        description: 'Find defects similar to a given query using semantic search.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Defect description to search for' },
-                maxResults: { type: 'number' },
-                threshold: { type: 'number' },
-            },
-            required: ['query'],
-        },
-        handler: wrap(findSimilarDefectsHandler),
-    },
-    {
-        name: 'quality_security_scan',
-        description: 'Scan code for security vulnerabilities. Returns findings with severity, location, and remediation.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to scan' },
-                scanType: { type: 'string', enum: ['sast', 'dependency', 'all'] },
-                severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-                excludePatterns: { type: 'array', items: { type: 'string' } },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(securityScanHandler),
-    },
-    {
-        name: 'quality_audit_compliance',
-        description: 'Audit code for compliance with security standards (OWASP, CWE, GDPR, etc.).',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetPath: { type: 'string', description: 'Path to file/directory to audit' },
-                standards: { type: 'array', items: { type: 'string' } },
-                strict: { type: 'boolean' },
-            },
-            required: ['targetPath'],
-        },
-        handler: wrap(auditComplianceHandler),
-    },
     {
         name: 'quality_detect_secrets',
         description: 'Detect hardcoded secrets, API keys, and credentials in code.',
@@ -286,23 +54,5 @@ export const qualityTools = [
         },
         handler: wrap(detectSecretsHandler),
     },
-    {
-        name: 'quality_chaos_inject',
-        description: 'Inject chaos (failures, latency, errors) into a target to test resilience.',
-        category: 'quality',
-        version: '0.1.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                target: { type: 'string', description: 'Target service or component' },
-                failureType: { type: 'string', enum: ['latency', 'error', 'crash', 'resource-exhaustion', 'network-partition'] },
-                duration: { type: 'number' },
-                intensity: { type: 'number' },
-                dryRun: { type: 'boolean' },
-            },
-            required: ['target', 'failureType'],
-        },
-        handler: wrap(chaosInjectHandler),
-    },
 ];
 //# sourceMappingURL=quality-tools.js.map

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

@@ -13,8 +13,7 @@
 export interface SonaConfig {
     instantLoopEnabled: boolean;
     backgroundLoopEnabled: boolean;
-    loraLearningRate: number;
-    loraRank: number;
+    confidenceLearningRate: number;
     ewcLambda: number;
     maxTrajectorySize: number;
     patternThreshold: number;
@@ -104,7 +103,7 @@ declare class LocalSonaCoordinator {
      */
     addTrajectoryStep(step: TrajectoryStep): void;
     /**
-     * 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
@@ -116,10 +115,10 @@ declare 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.
      */
     distillLearning(bank: LocalReasoningBank): Promise<{
@@ -264,8 +263,8 @@ export declare function getSonaCoordinator(): LocalSonaCoordinator | null;
  */
 export declare function getReasoningBank(): LocalReasoningBank | null;
 /**
- * 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
@@ -276,7 +275,7 @@ export declare function endTrajectoryWithVerdict(verdict: 'success' | 'failure'
 } | null>;
 /**
  * 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
  */