monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/commands/neural-optimize.js

@@ -1,330 +0,0 @@
-/**
- * Neural optimize and export commands
- */
-import { output } from '../output.js';
-// ─── optimize subcommand ─────────────────────────────────────────────────────
-export const optimizeCommand = {
-    name: 'optimize',
-    description: 'Optimize pattern storage (Int8 quantization, memory compression)',
-    options: [
-        { name: 'method', type: 'string', description: 'Method: quantize, analyze, compact', default: 'quantize' },
-        { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
-    ],
-    examples: [
-        { command: 'monomind hooks intelligence optimize --method quantize', description: 'Quantize patterns to Int8' },
-        { command: 'monomind hooks intelligence optimize --method analyze -v', description: 'Analyze memory usage' },
-    ],
-    action: async (ctx) => {
-        const method = ctx.flags.method || 'quantize';
-        const verbose = ctx.flags.verbose === true;
-        output.writeln();
-        output.writeln(output.bold('Pattern Optimization (Real)'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: `Running ${method} optimization...`, spinner: 'dots' });
-        spinner.start();
-        try {
-            const { initializeIntelligence, getIntelligenceStats, getAllPatterns, compactPatterns } = await import('../memory/intelligence.js');
-            const fs = await import('fs');
-            const path = await import('path');
-            await initializeIntelligence();
-            const patterns = await getAllPatterns();
-            const stats = getIntelligenceStats();
-            const patternDir = path.join(process.cwd(), '.monomind', 'neural');
-            let beforeSize = 0;
-            try {
-                const patternFile = path.join(patternDir, 'patterns.json');
-                if (fs.existsSync(patternFile))
-                    beforeSize = fs.statSync(patternFile).size;
-            }
-            catch { /* ignore */ }
-            if (method === 'quantize') {
-                spinner.setText('Applying Int8 quantization to pattern embeddings...');
-                let quantized = 0;
-                let savedBytes = 0;
-                // Int8 quantization: compress Float32 embeddings to Int8 by scaling to [-127, 127]
-                // Reduces embedding storage by ~4x with minimal retrieval quality loss.
-                const quantizedPatterns = patterns.map(p => {
-                    if (!p.embedding || p.embedding.length === 0)
-                        return p;
-                    const maxAbs = p.embedding.reduce((m, v) => Math.max(m, Math.abs(v)), 1e-8);
-                    const scale = 127 / maxAbs;
-                    const int8Embedding = Array.from(p.embedding).map((v) => Math.round(v * scale) / scale);
-                    savedBytes += (p.embedding.length * 4) - (p.embedding.length * 1);
-                    quantized++;
-                    return { ...p, embedding: int8Embedding, _quantized: true, _scale: scale };
-                });
-                const patternFile = path.join(patternDir, 'patterns.json');
-                const { writeJsonFileAtomic } = await import('../utils/json-file.js');
-                writeJsonFileAtomic(patternFile, quantizedPatterns);
-                spinner.succeed(`Quantized ${quantized} patterns`);
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20 },
-                    ],
-                    data: [
-                        { metric: 'Patterns Quantized', value: String(quantized) },
-                        { metric: 'Memory Saved', value: `~${(savedBytes / 1024).toFixed(1)} KB` },
-                        { metric: 'Compression', value: '~4x (Float32 → Int8)' },
-                        { metric: 'Quality Impact', value: 'Minimal (<1% cosine error)' },
-                    ],
-                });
-                return { success: true, data: { quantized, savedBytes } };
-            }
-            else if (method === 'analyze') {
-                spinner.succeed('Analysis complete');
-                output.writeln();
-                output.writeln(output.bold('Pattern Memory Analysis'));
-                const embeddingBytes = patterns.reduce((sum, p) => sum + (p.embedding?.length || 0) * 4, 0);
-                const metadataEstimate = patterns.length * 100;
-                output.printTable({
-                    columns: [
-                        { key: 'component', header: 'Component', width: 25 },
-                        { key: 'size', header: 'Size', width: 18 },
-                        { key: 'count', header: 'Count', width: 12 },
-                    ],
-                    data: [
-                        { component: 'Pattern Embeddings (F32)', size: `${(embeddingBytes / 1024).toFixed(1)} KB`, count: String(patterns.length) },
-                        { component: 'Pattern Metadata', size: `${(metadataEstimate / 1024).toFixed(1)} KB`, count: '-' },
-                        { component: 'Total In-Memory', size: `${((embeddingBytes + metadataEstimate) / 1024).toFixed(1)} KB`, count: '-' },
-                        { component: 'Storage (patterns.json)', size: `${(beforeSize / 1024).toFixed(1)} KB`, count: '-' },
-                        { component: 'Trajectories', size: '-', count: String(stats.trajectoriesRecorded) },
-                    ],
-                });
-                if (verbose) {
-                    output.writeln();
-                    output.writeln(output.bold('Optimization Recommendations'));
-                    const recommendations = [];
-                    if (patterns.length > 1000)
-                        recommendations.push('- Consider pruning low-usage patterns');
-                    if (embeddingBytes > 1024 * 1024)
-                        recommendations.push('- Int8 quantization would reduce memory by ~75%');
-                    if (stats.trajectoriesRecorded > 100)
-                        recommendations.push('- Trajectory consolidation available');
-                    if (recommendations.length === 0)
-                        recommendations.push('- Patterns are already well optimized');
-                    recommendations.forEach(r => output.writeln(r));
-                }
-            }
-            else if (method === 'compact') {
-                spinner.setText('Compacting pattern storage...');
-                const compacted = await compactPatterns(0.95);
-                spinner.succeed(`Compacted ${compacted.removed} patterns`);
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 20 },
-                        { key: 'value', header: 'Value', width: 15 },
-                    ],
-                    data: [
-                        { metric: 'Patterns Before', value: String(compacted.before) },
-                        { metric: 'Patterns After', value: String(compacted.after) },
-                        { metric: 'Removed', value: String(compacted.removed) },
-                        { metric: 'Similarity Threshold', value: '95%' },
-                    ],
-                });
-            }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail('Optimization failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// ─── export subcommand ───────────────────────────────────────────────────────
-export const exportCommand = {
-    name: 'export',
-    description: 'Export stored patterns to IPFS for sharing (Ed25519 signed)',
-    options: [
-        { name: 'model', short: 'm', type: 'string', description: 'Model ID or category to export' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output file path (optional)' },
-        { name: 'ipfs', short: 'i', type: 'boolean', description: 'Pin to IPFS (requires Pinata credentials)' },
-        { name: 'sign', short: 's', type: 'boolean', description: 'Sign with Ed25519 key', default: 'true' },
-        { name: 'strip-pii', type: 'boolean', description: 'Strip potential PII from export', default: 'true' },
-        { name: 'name', short: 'n', type: 'string', description: 'Custom name for exported model' },
-    ],
-    examples: [
-        { command: 'monomind hooks intelligence export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
-        { command: 'monomind hooks intelligence export -m code-review -o ./export.json', description: 'Export to file' },
-    ],
-    action: async (ctx) => {
-        const modelId = ctx.flags.model || 'all';
-        const outputFile = ctx.flags.output;
-        const pinToIpfs = ctx.flags.ipfs;
-        const signExport = ctx.flags.sign !== false;
-        const stripPii = ctx.flags['strip-pii'] !== false;
-        const customName = ctx.flags.name;
-        output.writeln();
-        output.writeln(output.bold('Secure Pattern Export'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Preparing export...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const crypto = await import('crypto');
-            spinner.setText('Collecting stored patterns...');
-            const { getIntelligenceStats, flushPatterns } = await import('../memory/intelligence.js');
-            await flushPatterns();
-            const stats = await getIntelligenceStats();
-            // SECURITY: Build export data — NEVER include secrets
-            const exportData = {
-                type: 'learning-pattern',
-                version: '1.0.0',
-                name: customName || `monomind-model-${Date.now()}`,
-                exportedAt: new Date().toISOString(),
-                modelId,
-                patterns: [],
-                metadata: {
-                    sourceVersion: '3.0.0-alpha',
-                    piiStripped: stripPii,
-                    signed: signExport,
-                    accuracy: 0,
-                    totalUsage: 0,
-                },
-            };
-            const memoryDir = path.join(process.cwd(), '.monomind', 'neural');
-            const patternsFile = path.join(memoryDir, 'patterns.json');
-            if (fs.existsSync(patternsFile)) {
-                const MAX_PATTERNS_BYTES = 100 * 1024 * 1024;
-                const patStat = fs.statSync(patternsFile);
-                if (patStat.size > MAX_PATTERNS_BYTES) {
-                    spinner.fail(`patterns.json too large to export safely (${patStat.size} bytes)`);
-                    return { success: false, exitCode: 1 };
-                }
-                const patternsRaw = fs.readFileSync(patternsFile, 'utf8');
-                const patternsJson = JSON.parse(patternsRaw);
-                if (patternsJson && typeof patternsJson === 'object' && ('__proto__' in patternsJson || 'constructor' in patternsJson)) {
-                    spinner.fail('Prototype pollution attempt detected in patterns.json');
-                    return { success: false, exitCode: 1 };
-                }
-                const patterns = patternsJson;
-                for (const pattern of patterns) {
-                    if (stripPii && pattern.content) {
-                        pattern.content = pattern.content
-                            .replace(/\/Users\/[^\/]+/g, '/Users/[REDACTED]')
-                            .replace(/\/home\/[^\/]+/g, '/home/[REDACTED]')
-                            .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL_REDACTED]')
-                            .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '[IP_REDACTED]');
-                    }
-                    exportData.patterns.push({
-                        id: pattern.id || crypto.randomBytes(8).toString('hex'),
-                        trigger: pattern.trigger || pattern.type || 'general',
-                        action: pattern.action || pattern.recommendation || 'apply-pattern',
-                        confidence: pattern.confidence || 0.85,
-                        usageCount: pattern.usageCount || 1,
-                    });
-                }
-            }
-            exportData.metadata.accuracy = stats.retrievalPrecision || 0.85;
-            exportData.metadata.totalUsage = exportData.patterns.reduce((sum, p) => sum + p.usageCount, 0);
-            spinner.setText('Generating secure signature...');
-            let signature = null;
-            let publicKey = null;
-            if (signExport) {
-                const { webcrypto } = crypto;
-                const keyPair = await webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, ['sign', 'verify']
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                );
-                const exportBytes = new TextEncoder().encode(JSON.stringify(exportData));
-                const signatureBytes = await webcrypto.subtle.sign('Ed25519', keyPair.privateKey, exportBytes);
-                signature = Buffer.from(signatureBytes).toString('hex');
-                const publicKeyBytes = await webcrypto.subtle.exportKey('raw', keyPair.publicKey);
-                publicKey = Buffer.from(publicKeyBytes).toString('hex');
-            }
-            const exportPackage = {
-                pinataContent: exportData,
-                pinataMetadata: {
-                    name: exportData.name,
-                    keyvalues: { type: 'learning-pattern', version: '1.0.0', signed: signExport ? 'true' : 'false' },
-                },
-                signature,
-                publicKey: publicKey ? `ed25519:${publicKey}` : null,
-            };
-            // SECURITY AUDIT: Ensure no secrets in export
-            const exportStr = JSON.stringify(exportPackage);
-            const secretPatterns = [
-                /sk-ant-[a-zA-Z0-9-]+/,
-                /sk-[a-zA-Z0-9]{48}/,
-                /AIza[a-zA-Z0-9-_]{35}/,
-                /pinata_[a-zA-Z0-9]{20,}/,
-                /-----BEGIN.*KEY-----/,
-            ];
-            for (const pattern of secretPatterns) {
-                if (pattern.test(exportStr)) {
-                    spinner.fail('SECURITY: Export contains potential API keys - aborting');
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            if (outputFile) {
-                const resolvedOut = path.resolve(outputFile);
-                const cwd = process.cwd();
-                if (!resolvedOut.startsWith(cwd + path.sep) && resolvedOut !== cwd) {
-                    spinner.fail(`--output path escapes project directory: ${outputFile}`);
-                    return { success: false, exitCode: 1 };
-                }
-                const { writeJsonFileAtomic } = await import('../utils/json-file.js');
-                writeJsonFileAtomic(resolvedOut, exportPackage);
-                spinner.succeed(`Exported to: ${outputFile}`);
-            }
-            if (pinToIpfs) {
-                spinner.setText('Pinning to IPFS...');
-                const pinataKey = process.env.PINATA_API_KEY;
-                const pinataSecret = process.env.PINATA_API_SECRET;
-                if (!pinataKey || !pinataSecret) {
-                    spinner.fail('PINATA_API_KEY and PINATA_API_SECRET required for IPFS export');
-                    output.writeln(output.dim('Set these in your environment or .env file'));
-                    return { success: false, exitCode: 1 };
-                }
-                const response = await fetch('https://api.pinata.cloud/pinning/pinJSONToIPFS', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'pinata_api_key': pinataKey,
-                        'pinata_secret_api_key': pinataSecret,
-                    },
-                    body: JSON.stringify(exportPackage),
-                });
-                if (!response.ok) {
-                    const error = await response.text();
-                    spinner.fail(`IPFS pin failed: ${error}`);
-                    return { success: false, exitCode: 1 };
-                }
-                const result = await response.json();
-                spinner.succeed('Successfully exported to IPFS');
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'property', header: 'Property', width: 20 },
-                        { key: 'value', header: 'Value', width: 50 },
-                    ],
-                    data: [
-                        { property: 'CID', value: result.IpfsHash },
-                        { property: 'Size', value: `${result.PinSize} bytes` },
-                        { property: 'Gateway URL', value: `https://gateway.pinata.cloud/ipfs/${result.IpfsHash}` },
-                        { property: 'Patterns', value: String(exportData.patterns.length) },
-                        { property: 'Signed', value: signExport ? 'Yes (Ed25519)' : 'No' },
-                        { property: 'PII Stripped', value: stripPii ? 'Yes' : 'No' },
-                    ],
-                });
-                output.writeln();
-                output.writeln(output.success('Share this CID for others to import your trained patterns'));
-                output.writeln(output.dim(`Import command: monomind hooks intelligence import --cid ${result.IpfsHash}`));
-            }
-            if (!outputFile && !pinToIpfs) {
-                spinner.succeed('Export prepared');
-                output.writeln();
-                output.writeln(JSON.stringify(exportPackage, null, 2));
-            }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail(`Export failed: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-//# sourceMappingURL=neural-optimize.js.map

package/packages/@monomind/cli/dist/src/commands/neural-registry.d.ts

@@ -1,7 +0,0 @@
-/**
- * Neural registry commands — list and import pattern sets from IPFS
- */
-import type { Command } from '../types.js';
-export declare const listCommand: Command;
-export declare const importCommand: Command;
-//# sourceMappingURL=neural-registry.d.ts.map

package/packages/@monomind/cli/dist/src/commands/neural-registry.js

@@ -1,290 +0,0 @@
-/**
- * Neural registry commands — list and import pattern sets from IPFS
- */
-import { output } from '../output.js';
-// ─── list subcommand ─────────────────────────────────────────────────────────
-export const listCommand = {
-    name: 'list',
-    description: 'List available pattern sets from the official registry',
-    options: [
-        { name: 'category', type: 'string', description: 'Filter by category (security, quality, performance, etc.)' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json, simple', default: 'table' },
-        { name: 'cid', type: 'string', description: 'Custom registry CID (default: official registry)' },
-    ],
-    examples: [
-        { command: 'monomind hooks intelligence list', description: 'List all available models' },
-        { command: 'monomind hooks intelligence list --category security', description: 'List only security models' },
-        { command: 'monomind hooks intelligence list -f json', description: 'Output as JSON' },
-    ],
-    action: async (ctx) => {
-        const category = ctx.flags.category;
-        const format = ctx.flags.format || 'table';
-        const customCid = ctx.flags.cid;
-        const registryCid = customCid || 'QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc';
-        output.writeln();
-        output.writeln(output.bold('Pre-trained Model Registry'));
-        output.writeln(output.dim('─'.repeat(60)));
-        const spinner = output.createSpinner({ text: 'Fetching model registry...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const gateways = ['https://gateway.pinata.cloud', 'https://ipfs.io', 'https://dweb.link'];
-            let registry = null;
-            for (const gateway of gateways) {
-                try {
-                    const response = await fetch(`${gateway}/ipfs/${registryCid}`, {
-                        signal: AbortSignal.timeout(15000),
-                        headers: { 'Accept': 'application/json' },
-                    });
-                    if (response.ok) {
-                        const MAX_REGISTRY_BYTES = 50 * 1024 * 1024;
-                        const buf = await response.arrayBuffer();
-                        if (buf.byteLength > MAX_REGISTRY_BYTES)
-                            throw new Error(`Registry response too large: ${buf.byteLength} bytes`);
-                        registry = JSON.parse(new TextDecoder().decode(buf));
-                        break;
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (!registry || !registry.models) {
-                spinner.fail('Could not fetch model registry');
-                return { success: false, exitCode: 1 };
-            }
-            let models = registry.models;
-            if (category) {
-                models = models.filter(m => m.category === category ||
-                    m.id.includes(category) ||
-                    m.name.toLowerCase().includes(category.toLowerCase()));
-                spinner.succeed(`Found ${models.length} models matching "${category}"`);
-            }
-            else {
-                spinner.succeed(`Found ${registry.models.length} models`);
-            }
-            if (models.length === 0) {
-                output.writeln(output.warning(`No models found for category: ${category}`));
-                output.writeln(output.dim('Available categories: security, quality, performance, testing, api, debugging, refactoring, documentation'));
-                return { success: false, exitCode: 1 };
-            }
-            output.writeln();
-            if (format === 'json') {
-                output.writeln(JSON.stringify(models, null, 2));
-            }
-            else if (format === 'simple') {
-                for (const model of models) {
-                    output.writeln(`${model.id} (${model.category}) - ${model.patterns.length} patterns, ${(model.metadata.accuracy * 100).toFixed(0)}% accuracy`);
-                }
-            }
-            else {
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Model ID', width: 35 },
-                        { key: 'category', header: 'Category', width: 14 },
-                        { key: 'patterns', header: 'Patterns', width: 10 },
-                        { key: 'accuracy', header: 'Accuracy', width: 10 },
-                        { key: 'usage', header: 'Usage', width: 10 },
-                    ],
-                    data: models.map(m => ({
-                        id: m.id, category: m.category,
-                        patterns: String(m.patterns.length),
-                        accuracy: `${(m.metadata.accuracy * 100).toFixed(0)}%`,
-                        usage: m.metadata.totalUsage.toLocaleString(),
-                    })),
-                });
-                output.writeln();
-                output.writeln(output.dim('Registry CID: ' + registryCid));
-                output.writeln();
-                output.writeln(output.bold('Import Commands:'));
-                output.writeln(output.dim('  All models:      ') + `monomind hooks intelligence import --cid ${registryCid}`);
-                if (category) {
-                    output.writeln(output.dim(`  ${category} only: `) + `monomind hooks intelligence import --cid ${registryCid} --category ${category}`);
-                }
-                else {
-                    output.writeln(output.dim('  By category:     ') + `monomind hooks intelligence import --cid ${registryCid} --category <category>`);
-                }
-            }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail(`Failed to list models: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// ─── import subcommand ───────────────────────────────────────────────────────
-export const importCommand = {
-    name: 'import',
-    description: 'Import pattern sets from IPFS with signature verification',
-    options: [
-        { name: 'cid', short: 'c', type: 'string', description: 'IPFS CID to import from' },
-        { name: 'file', short: 'f', type: 'string', description: 'Local file to import' },
-        { name: 'verify', short: 'v', type: 'boolean', description: 'Verify Ed25519 signature', default: 'true' },
-        { name: 'merge', type: 'boolean', description: 'Merge with existing patterns (vs replace)', default: 'true' },
-        { name: 'category', type: 'string', description: 'Only import patterns from specific category' },
-    ],
-    examples: [
-        { command: 'monomind hooks intelligence import --cid QmXxx...', description: 'Import from IPFS' },
-        { command: 'monomind hooks intelligence import -f ./patterns.json --verify', description: 'Import from file' },
-        { command: 'monomind hooks intelligence import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
-    ],
-    action: async (ctx) => {
-        const cid = ctx.flags.cid;
-        const file = ctx.flags.file;
-        const verifySignature = ctx.flags.verify !== false;
-        const merge = ctx.flags.merge !== false;
-        const categoryFilter = ctx.flags.category;
-        if (!cid && !file) {
-            output.writeln(output.error('Either --cid or --file is required'));
-            return { success: false, exitCode: 1 };
-        }
-        output.writeln();
-        output.writeln(output.bold('Secure Pattern Import'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Fetching model...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const crypto = await import('crypto');
-            let importData = null;
-            if (cid) {
-                const gateways = ['https://gateway.pinata.cloud', 'https://ipfs.io', 'https://dweb.link'];
-                for (const gateway of gateways) {
-                    try {
-                        spinner.setText(`Fetching from ${gateway}...`);
-                        const response = await fetch(`${gateway}/ipfs/${cid}`, {
-                            signal: AbortSignal.timeout(30000),
-                            headers: { 'Accept': 'application/json' },
-                        });
-                        if (response.ok) {
-                            const MAX_IMPORT_BYTES = 50 * 1024 * 1024;
-                            const importBuf = await response.arrayBuffer();
-                            if (importBuf.byteLength > MAX_IMPORT_BYTES)
-                                throw new Error(`Import response too large: ${importBuf.byteLength} bytes`);
-                            importData = JSON.parse(new TextDecoder().decode(importBuf));
-                            break;
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-                if (!importData) {
-                    spinner.fail('Could not fetch from any IPFS gateway');
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            else {
-                if (!fs.existsSync(file)) {
-                    spinner.fail(`File not found: ${file}`);
-                    return { success: false, exitCode: 1 };
-                }
-                const stat = fs.statSync(file);
-                const MAX_IMPORT_BYTES = 50 * 1024 * 1024;
-                if (stat.size > MAX_IMPORT_BYTES) {
-                    spinner.fail(`Import file too large: ${stat.size} bytes (max ${MAX_IMPORT_BYTES})`);
-                    return { success: false, exitCode: 1 };
-                }
-                importData = JSON.parse(fs.readFileSync(file, 'utf8'));
-            }
-            if (!importData) {
-                spinner.fail('No import data available');
-                return { success: false, exitCode: 1 };
-            }
-            // SECURITY: Verify signature — fail-CLOSED (no bypass if missing or malformed)
-            if (verifySignature) {
-                if (!importData.signature || !importData.publicKey) {
-                    spinner.fail('SECURITY: --verify requested but payload is unsigned. Aborting (use --no-verify to override).');
-                    return { success: false, exitCode: 1 };
-                }
-                spinner.setText('Verifying Ed25519 signature...');
-                try {
-                    const { webcrypto } = crypto;
-                    const publicKeyHex = importData.publicKey.replace('ed25519:', '');
-                    const publicKeyBytes = Buffer.from(publicKeyHex, 'hex');
-                    const signatureBytes = Buffer.from(importData.signature, 'hex');
-                    const publicKey = await webcrypto.subtle.importKey('raw', publicKeyBytes, { name: 'Ed25519' }, false, ['verify']);
-                    const dataBytes = new TextEncoder().encode(JSON.stringify(importData.pinataContent));
-                    const valid = await webcrypto.subtle.verify('Ed25519', publicKey, signatureBytes, dataBytes);
-                    if (!valid) {
-                        spinner.fail('Signature verification FAILED - data may be tampered');
-                        return { success: false, exitCode: 1 };
-                    }
-                    output.writeln(output.success('Signature verified'));
-                }
-                catch (err) {
-                    // FAIL-CLOSED: any error during verification must reject the import
-                    spinner.fail(`SECURITY: Signature verification error: ${err instanceof Error ? err.message : String(err)}. Aborting.`);
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            spinner.setText('Importing patterns...');
-            const content = importData.pinataContent || importData;
-            let patterns = [];
-            const registry = content;
-            if (registry.models && Array.isArray(registry.models)) {
-                for (const model of registry.models) {
-                    if (!categoryFilter || model.category === categoryFilter || model.id.includes(categoryFilter)) {
-                        for (const pattern of model.patterns || []) {
-                            patterns.push({ ...pattern, category: model.category });
-                        }
-                    }
-                }
-            }
-            else {
-                patterns = content.patterns || [];
-            }
-            if (categoryFilter && patterns.length > 0) {
-                patterns = patterns.filter(p => p.category === categoryFilter || p.trigger.includes(categoryFilter));
-            }
-            // Validate patterns (security check)
-            const suspicious = ['eval(', 'Function(', 'exec(', 'spawn(', 'child_process', 'rm -rf', 'sudo', '<script>', 'javascript:', 'data:'];
-            const validPatterns = patterns.filter(p => {
-                const c = JSON.stringify(p);
-                return !suspicious.some(s => c.includes(s));
-            });
-            if (validPatterns.length < patterns.length) {
-                output.writeln(output.warning(`Filtered ${patterns.length - validPatterns.length} suspicious patterns`));
-            }
-            const memoryDir = path.join(process.cwd(), '.monomind', 'neural');
-            if (!fs.existsSync(memoryDir))
-                fs.mkdirSync(memoryDir, { recursive: true });
-            const patternsFile = path.join(memoryDir, 'patterns.json');
-            let existingPatterns = [];
-            if (merge && fs.existsSync(patternsFile) && fs.statSync(patternsFile).size <= 50 * 1024 * 1024) {
-                existingPatterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
-            }
-            const existingIds = new Set(existingPatterns.map(p => p.id));
-            const newPatterns = validPatterns.filter(p => !existingIds.has(p.id));
-            const finalPatterns = merge ? [...existingPatterns, ...newPatterns] : validPatterns;
-            const tmpPatterns = `${patternsFile}.${process.pid}.${Date.now()}.tmp`;
-            fs.writeFileSync(tmpPatterns, JSON.stringify(finalPatterns, null, 2), { flag: 'wx' });
-            fs.renameSync(tmpPatterns, patternsFile);
-            spinner.succeed('Import complete');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20 },
-                ],
-                data: [
-                    { metric: 'Patterns Imported', value: String(validPatterns.length) },
-                    { metric: 'New Patterns', value: String(newPatterns.length) },
-                    { metric: 'Total Patterns', value: String(finalPatterns.length) },
-                    { metric: 'Signature Verified', value: importData.signature ? 'Yes' : 'N/A' },
-                    { metric: 'Merge Mode', value: merge ? 'Yes' : 'Replace' },
-                ],
-            });
-            output.writeln();
-            output.writeln(output.success('Patterns imported and ready to use'));
-            output.writeln(output.dim('Run "monomind hooks intelligence patterns --action list" to see imported patterns'));
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail(`Import failed: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-//# sourceMappingURL=neural-registry.js.map

package/packages/@monomind/cli/dist/src/commands/org-observe.d.ts

@@ -1,18 +0,0 @@
-import type { CommandContext, CommandResult } from '../types.js';
-/** Validate org config(s) against OrgDefSchema — the exact parse `org run`/`org serve`
- * perform — plus the structural invariants the runtime assumes but the schema can't
- * express (single root role, resolvable reports_to, unique ids, parseable schedule). */
-export declare const validateAction: (ctx: CommandContext) => Promise<CommandResult>;
-/** `org logs <name> [--run id] [--role r] [--follow]` — formatted bus.jsonl tail. */
-export declare const logsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
-/** `org report <name> [--run id] [--all]` — summarize a run (or list run history). */
-export declare const reportAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
-/** `org questions <name> [--all]` — list pending (or all) ask_human questions. */
-export declare const questionsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
-/** `org answer <name> <question-id> <answer...>` — answer a pending ask_human question.
- *  Delivers live via the hosting daemon's /api/answer-question when the org is running
- *  (broker lookup); otherwise records the answer and queues it for the next run. */
-export declare const answerAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
-/** `org create <name> --template <t> [--goal g] [--schedule s]` — scaffold a config from a template. */
-export declare const createAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
-//# sourceMappingURL=org-observe.d.ts.map