079project 1.0.0

package/main_Study.cjs

@@ -0,0 +1,3230 @@
+//this is the study version of the AI, it is used to study and learn from the data
+// it will send the pre-trained model to the server version by redis
+const axios = require('axios');
+const { exec } = require('child_process');
+const express = require('express');
+const redis = require('redis');
+const fs = require('fs');
+const path = require('path');
+const tf = require('@tensorflow/tfjs'); // 依然用这个
+const net = require('net');
+const http = require('http');
+const cluster = require('cluster');
+const protobuf = require('protobufjs');
+const runtimeProtoPath = path.join(__dirname, 'runtime.proto');
+let RuntimeMessage = null;
+const worker = require('worker_threads');
+const workerpool = require('workerpool');
+let redisClient = null;          // 新增：模块级引用
+let isShuttingDown = false;      // 新增：退出标志
+const crossTimers = [];          // 新增：记录定时器，便于退出时清理
+function registerInterval(fn, ms) { const t = setInterval(fn, ms); crossTimers.push(t); return t; }
+const os = require('os');
+const csvParse = require('csv-parse/sync'); // 需要安装 csv-parse
+const MAX_WORKERS = os.cpus().length;
+const pool = workerpool.pool(path.join(__dirname, 'memeMergeWorker.cjs'), {
+    minWorkers: 1,
+    maxWorkers: MAX_WORKERS,
+    workerType: 'process'
+});
+const natural = require('natural');
+const STOP_WORDS = natural.stopwords; // 英文停用词
+
+console.log(`[WORKERS] 工作池已创建，最大工作进程数: ${MAX_WORKERS}`);
+protobuf.load(runtimeProtoPath, (err, root) => {
+    if (err) throw err;
+    RuntimeMessage = root.lookupType('Runtime');
+});
+// 全局配置
+global.config = {
+    masterPortOfMain: process.argv[2],
+    emitExitport: process.argv[3] || 8641
+};
+const modelDefaults = {
+    decayFactor: 0.5,
+    maxMemeWords: 100,
+    minOverlapThreshold: 2,
+    maliciousThreshold: 0.7,
+    learningIterations: 3,
+    iteration: 5,
+    threshold: 3,
+    decay: 1,
+    decayK: 1,
+    maxLen: 16,
+    edgeWeight: 1
+};
+const currentModelParams = { ...modelDefaults };
+async function batchAddPoints(graph, pointsArr, batchSize = 500) {
+    if (!graph || !pointsArr || !Array.isArray(pointsArr)) {
+        console.error('[BATCH] 无效的参数:', {
+            hasGraph: !!graph,
+            hasPointsArr: !!pointsArr,
+            isArray: Array.isArray(pointsArr)
+        });
+        return;
+    }
+
+    for (let i = 0; i < pointsArr.length; i += batchSize) {
+        const batch = pointsArr.slice(i, i + batchSize);
+        for (const item of batch) {
+            if (item && item.key && item.value && item.value.pointID) {
+                try {
+                    const connects = Array.isArray(item.value.connect) ? item.value.connect : [];
+                    graph.addPoint(item.value.pointID, connects);
+                } catch (err) {
+                    console.error('[BATCH] 添加点失败:', item.value.pointID, err.message);
+                }
+            }
+        }
+        await new Promise(resolve => setImmediate(resolve));
+    }
+}
+// 反触发机制
+async function antiTrigger(onContinue, onExit) {
+    const PORT = global.config.emitExitport || 8641;
+    let server;
+    let shouldExit = false;
+    let lastRequestTime = Date.now();
+
+    // 1. 尝试监听端口
+    const tryListen = () => new Promise(resolve => {
+        server = net.createServer().listen(PORT, () => resolve(true));
+        server.on('error', () => resolve(false));
+    });
+
+    const canListen = await tryListen();
+
+    if (canListen) {
+        // 监听成功，10秒内检测是否有连接
+        console.log(`[ANTI-TRIGGER] 端口${PORT}监听成功，等待10秒...`);
+        let timer = setTimeout(() => {
+            server.close();
+            onContinue();
+        }, 10000);
+
+        server.on('connection', socket => {
+            // 有连接，说明有外部监控，进入等待模式
+            clearTimeout(timer);
+            socket.destroy();
+            server.close();
+            console.log(`[ANTI-TRIGGER] 检测到外部请求，等待20秒后启动主逻辑...`);
+            setTimeout(onContinue, 20000);
+        });
+    } else {
+        // 监听失败，说明端口被占用，定时发送请求
+        console.log(`[ANTI-TRIGGER] 端口${PORT}被占用，进入监控模式...`);
+        let interval = setInterval(() => {
+            const req = http.request({ port: PORT, timeout: 2000 }, res => {
+                lastRequestTime = Date.now();
+                res.on('data', () => { });
+            });
+            req.on('error', () => { });
+            req.end();
+        }, 2000);
+
+        // 检查请求是否消失
+        let checkInterval = setInterval(() => {
+            if (Date.now() - lastRequestTime > 4000) {
+                // 4秒内没有收到响应，认为监控消失
+                clearInterval(interval);
+                clearInterval(checkInterval);
+                console.log(`[ANTI-TRIGGER] 监控请求消失，保存数据并退出...`);
+                shouldExit = true;
+                if (onExit) onExit();
+                process.exit(0);
+            }
+        }, 1000);
+
+        // 10秒后继续主逻辑
+        setTimeout(() => {
+            if (!shouldExit) {
+                clearInterval(interval);
+                clearInterval(checkInterval);
+                onContinue();
+            }
+        }, 10000);
+    }
+}
+function verifySystemConsistency(sourceRuntime, targetRuntime) {
+    console.log('[VERIFY] 开始验证系统一致性...');
+    console.log(`[VERIFY] 源词表大小: ${sourceRuntime.vocabManager.vocab.length}, 目标: ${targetRuntime.vocabManager.vocab.length}`);
+    console.log(`[VERIFY] 源KVM条目: ${sourceRuntime.kvm.memory.size}, 目标: ${targetRuntime.kvm.memory.size}`);
+    console.log(`[VERIFY] 源Spider: ${!!sourceRuntime.spider}, 目标: ${!!targetRuntime.spider}`);
+    // 检查部分词是否能在目标系统找到
+    const sample = sourceRuntime.vocabManager.vocab.slice(0, 5);
+    for (const word of sample) {
+        const inTarget = targetRuntime.vocabManager.word2idx.has(word);
+        console.log(`[VERIFY] 词 "${word}" 在目标系统: ${inTarget}`);
+    }
+}
+const app = express();
+const bodyParser = require('body-parser');
+const readline = require('readline');
+
+app.use(bodyParser.json());
+app.use(bodyParser.urlencoded({ extended: true }));
+app.use(express.static(path.join(__dirname, 'public')));
+
+// 持久化路径
+const SAVE_PATH = path.join(__dirname, 'runtime_data.json');
+
+
+
+
+class SnapshotManager {
+    constructor(runtime, snapshotDir = path.join(__dirname, 'snapshots')) {
+        this.runtime = runtime;
+        this.snapshotDir = snapshotDir;
+        this.snapshotList = [];
+        this.isCreatingSnapshot = false;
+        this.autoSnapshotTimer = null;
+
+        // 创建快照目录
+        if (!fs.existsSync(this.snapshotDir)) {
+            fs.mkdirSync(this.snapshotDir, { recursive: true });
+        }
+
+        // 加载现有快照列表
+        this.loadSnapshotList();
+    }
+
+    loadSnapshotList() {
+        try {
+            const files = fs.readdirSync(this.snapshotDir).filter(f => f.endsWith('.snapshot'));
+            this.snapshotList = files.map(f => ({
+                id: f.replace('.snapshot', ''),
+                timestamp: parseInt(f.split('_')[0]),
+                name: f.replace(/^\d+_/, '').replace('.snapshot', ''),
+                path: path.join(this.snapshotDir, f)
+            })).sort((a, b) => b.timestamp - a.timestamp); // 按时间降序排序
+
+            console.log(`[SNAPSHOT] 加载了${this.snapshotList.length}个快照`);
+        } catch (e) {
+            console.error('[SNAPSHOT] 加载快照列表失败:', e);
+            this.snapshotList = [];
+        }
+    }
+
+    async createSnapshot(name = 'auto') {
+        // 防止并发创建
+        if (this.isCreatingSnapshot) {
+            console.log('[SNAPSHOT] 另一个快照正在创建中，跳过');
+            return null;
+        }
+
+        this.isCreatingSnapshot = true;
+        console.time('snapshotCreation');
+
+        try {
+            const timestamp = Date.now();
+            const snapshotId = `${timestamp}_${name}`;
+            const filePath = path.join(this.snapshotDir, `${snapshotId}.snapshot`);
+
+            console.log(`[SNAPSHOT] 开始创建快照: ${snapshotId}`);
+
+            // 准备快照数据，分批处理以优化性能
+            const snapshotData = {
+                id: snapshotId,
+                timestamp,
+                name,
+                createDate: new Date().toISOString(),
+                memes: this.runtime.graph.getAllPoints(),
+                wordGraph: Array.from(this.runtime.wordGraph.points.values()),
+                kvm: Array.from(this.runtime.kvm.memory.entries()),
+                vocab: this.runtime.vocabManager.vocab,
+                wordAccessLog: Array.from(this.runtime.wordAccessLog ? this.runtime.wordAccessLog.entries() : [])
+            };
+
+            // 写入临时文件，然后原子重命名以确保数据完整性
+            const tempPath = `${filePath}.temp`;
+            await fs.promises.writeFile(tempPath, JSON.stringify(snapshotData), 'utf-8');
+            await fs.promises.rename(tempPath, filePath);
+
+            // 更新快照列表
+            const snapshotInfo = {
+                id: snapshotId,
+                timestamp,
+                name,
+                path: filePath
+            };
+            this.snapshotList.unshift(snapshotInfo);
+
+            console.timeEnd('snapshotCreation');
+            console.log(`[SNAPSHOT] 快照创建成功: ${snapshotId}`);
+            return snapshotInfo;
+        } catch (e) {
+            console.error('[SNAPSHOT] 创建快照失败:', e);
+            return null;
+        } finally {
+            this.isCreatingSnapshot = false;
+        }
+    }
+
+    async restoreSnapshot(snapshotId) {
+        console.log(`[SNAPSHOT] 开始从快照恢复: ${snapshotId}`);
+        console.time('snapshotRestore');
+
+        // 查找快照
+        const snapshot = this.snapshotList.find(s => s.id === snapshotId);
+        if (!snapshot) {
+            console.error(`[SNAPSHOT] 快照不存在: ${snapshotId}`);
+            return false;
+        }
+
+        try {
+            // 读取快照文件
+            console.log(`[SNAPSHOT] 从文件读取数据: ${snapshot.path}`);
+            const dataStr = await fs.promises.readFile(snapshot.path, 'utf-8');
+            const data = JSON.parse(dataStr);
+
+            // 在恢复前创建自动备份
+            await this.createSnapshot(`auto_before_restore_${snapshotId}`);
+
+            // 清空当前运行时
+            console.log('[SNAPSHOT] 清空当前运行时...');
+            this.runtime.graph = new GraphDB();
+            this.runtime.wordGraph = new GraphDB();
+            this.runtime.kvm = new KVM();
+            this.runtime.wordAccessLog = new Map();
+
+            // 恢复图结构
+            console.log('[SNAPSHOT] 恢复模因网络...');
+            if (data.memes) {
+                const BATCH_SIZE = 500;
+                for (let i = 0; i < data.memes.length; i += BATCH_SIZE) {
+                    const batch = data.memes.slice(i, i + BATCH_SIZE);
+                    for (const point of batch) {
+                        this.runtime.graph.addPoint(point.pointID, point.connect);
+                    }
+                    // 让事件循环有机会处理其他事件
+                    await new Promise(resolve => setImmediate(resolve));
+                }
+            }
+
+            // 恢复词图
+            console.log('[SNAPSHOT] 恢复词语网络...');
+            if (data.wordGraph) {
+                const BATCH_SIZE = 1000;
+                for (let i = 0; i < data.wordGraph.length; i += BATCH_SIZE) {
+                    const batch = data.wordGraph.slice(i, i + BATCH_SIZE);
+                    for (const point of batch) {
+                        this.runtime.wordGraph.addPoint(point.pointID, point.connect);
+                    }
+                    await new Promise(resolve => setImmediate(resolve));
+                }
+            }
+
+            // 恢复KVM
+            console.log('[SNAPSHOT] 恢复键值存储...');
+            if (data.kvm) {
+                const BATCH_SIZE = 1000;
+                for (let i = 0; i < data.kvm.length; i += BATCH_SIZE) {
+                    const batch = data.kvm.slice(i, i + BATCH_SIZE);
+                    for (const [k, v] of batch) {
+                        this.runtime.kvm.set(k, v);
+                    }
+                    await new Promise(resolve => setImmediate(resolve));
+                }
+            }
+
+            // 恢复词表
+            console.log('[SNAPSHOT] 恢复词表...');
+            if (data.vocab) {
+                this.runtime.vocabManager.vocab = data.vocab;
+                this.runtime.vocabManager.updateMappings();
+            }
+
+            // 恢复词访问日志
+            console.log('[SNAPSHOT] 恢复词访问日志...');
+            if (data.wordAccessLog) {
+                this.runtime.wordAccessLog = new Map(data.wordAccessLog);
+            }
+
+            console.timeEnd('snapshotRestore');
+            console.log(`[SNAPSHOT] 成功从快照恢复: ${snapshotId}`);
+            return true;
+        } catch (e) {
+            console.error('[SNAPSHOT] 恢复快照失败:', e);
+            return false;
+        }
+    }
+
+    getSnapshotList() {
+        return this.snapshotList.map(({ id, timestamp, name }) => ({
+            id,
+            timestamp,
+            name,
+            date: new Date(timestamp).toLocaleString()
+        }));
+    }
+
+
+
+    setupAutoSnapshot(interval = 30 * 60 * 1000) { // 默认30分钟
+        // 清除可能存在的旧定时器
+        if (this.autoSnapshotTimer) {
+            clearInterval(this.autoSnapshotTimer);
+        }
+
+        // 设置新定时器
+        this.autoSnapshotTimer = setInterval(async () => {
+            // 检查系统是否空闲
+            if (global.ctrlA && !global.ctrlA.isLearning && !global.ctrlA.isMainLoopRunning) {
+                console.log('[SNAPSHOT] 系统空闲，开始自动创建快照');
+                await this.createSnapshot(`auto_${new Date().toLocaleDateString().replace(/\//g, '-')}`);
+
+                // 清理旧的自动快照，只保留最近10个
+                const autoSnapshots = this.snapshotList
+                    .filter(s => s.name.startsWith('auto_'))
+                    .sort((a, b) => b.timestamp - a.timestamp);
+
+                if (autoSnapshots.length > 10) {
+                    console.log('[SNAPSHOT] 清理旧的自动快照...');
+                    for (const s of autoSnapshots.slice(10)) {
+                        this.deleteSnapshot(s.id);
+                    }
+                }
+            } else {
+                console.log('[SNAPSHOT] 系统忙碌，跳过自动创建快照');
+            }
+        }, interval);
+
+        console.log(`[SNAPSHOT] 已设置自动快照，每${interval / 60000}分钟检查一次`);
+        return true;
+    }
+
+    stopAutoSnapshot() {
+        if (this.autoSnapshotTimer) {
+            clearInterval(this.autoSnapshotTimer);
+            this.autoSnapshotTimer = null;
+            console.log('[SNAPSHOT] 已停止自动快照');
+            return true;
+        }
+        return false;
+    }
+}
+
+
+class VocabManager {
+    constructor(spider) {
+        this.vocab = ['<PAD>', '<BOS>', '<EOS>', '<UNK>'];
+        this.word2idx = new Map();
+        this.spider = spider; // 持有 spider 实例
+        this.updateMappings();
+    }
+
+    // 优化 VocabManager.buildFromData 方法
+    async buildFromData(texts) {
+        console.time('vocabBuild');
+        const wordCounts = new Map();
+        for (let i = 0; i < texts.length; i++) {
+            // 先分词再归一化
+            let words = texts[i]
+                .toLowerCase()
+                .replace(/[^a-zA-Z\s]/g, ' ')
+                .split(/\s+/)
+                .filter(w => w.length > 0);
+            words = this.spider.lemmatizeWords(words);
+            for (const word of words) {
+                wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
+            }
+            if (i % 1000 === 0 && i > 0) await new Promise(r => setImmediate(r));
+        }
+        const MAX_VOCAB_SIZE = 100000;
+        const sortedWords = Array.from(wordCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, MAX_VOCAB_SIZE)
+            .map(([word]) => word);
+        const existingWords = new Set(this.vocab);
+        const newWords = sortedWords.filter(word => !existingWords.has(word));
+        this.vocab.push(...newWords);
+        //这里，在模因网络建立之前实现词归一化
+        //this.vocab.forEach(word => this.spider.lemmatizeWords(word))
+        this.updateMappings();
+        console.log(`Built vocab with ${this.vocab.length} words`);
+        console.timeEnd('vocabBuild');
+    }
+
+    // 从Spider加载并构建词表
+    buildVocabFromSpider(spider) {
+        if (!spider) {
+            console.warn('Spider not provided to buildVocabFromSpider');
+            return [];
+        }
+        const articles = spider.fetchArticles();
+        this.buildFromData(articles);
+        return articles;
+    }
+
+    // 添加新词
+    addWord(word) {
+        if (!this.word2idx.has(word)) {
+            this.vocab.push(word);
+            this.word2idx.set(word, this.vocab.length - 1);
+        }
+    }
+
+    // 更新映射
+    updateMappings() {
+        this.word2idx.clear();
+        this.vocab.forEach((word, idx) => {
+            this.word2idx.set(word, idx);
+        });
+    }
+
+    // 词转索引
+    wordsToIndices(words) {
+        return words.map(w => this.word2idx.get(w) || this.word2idx.get('<UNK>'));
+    }
+
+    // 索引转词
+    indicesToWords(indices) {
+        return indices.map(i => this.vocab[i] || '<UNK>');
+    }
+
+    // 获取词表大小
+    getsize() {
+        return this.vocab.length;
+    }
+}
+
+// 创建全局词表管理器
+global.vocabmanager = new VocabManager();
+
+class GraphDB {
+    // 点格式：{pointID, connect: [[lineweight, pointID, 0|1|2], ...]}
+    // 0: 双向，1: 指向自己，2: 指向对方
+    constructor() {
+        this.points = new Map();
+    }
+    // 确保 GraphDB 类有完整的单向连接支持
+    /**
+     * 添加专门的单向边
+     * @param {string} fromID - 起点ID
+     * @param {string} toID - 终点ID  
+     * @param {number} weight - 边权重
+     * @param {number} specificDirection - 具体方向类型(1=指向自己,2=指向对方)
+     */
+    addBidirectionalEdge(id1, id2, weight = 1) {
+        this.addEdge(id1, id2, weight, 0);
+    }
+    // 优化 addDirectionalEdge 方法
+    addDirectionalEdge(fromID, toID, weight = 1, specificDirection = 2) {
+        if (specificDirection !== 1 && specificDirection !== 2) {
+            specificDirection = 2; // 默认值而不是抛出错误
+        }
+
+        // 确保点存在
+        if (!this.points.has(fromID)) {
+            this.points.set(fromID, { pointID: fromID, connect: [] });
+        }
+        if (!this.points.has(toID)) {
+            this.points.set(toID, { pointID: toID, connect: [] });
+        }
+
+        const fromPoint = this.points.get(fromID);
+        const safeWeight = (typeof weight === 'number' && isFinite(weight)) ? weight : 1;
+
+        // 使用更高效的查找
+        let edgeExists = false;
+        for (let i = 0; i < fromPoint.connect.length; i++) {
+            if (fromPoint.connect[i][1] === toID && fromPoint.connect[i][2] === specificDirection) {
+                edgeExists = true;
+                break;
+            }
+        }
+
+        if (!edgeExists) {
+            fromPoint.connect.push([safeWeight, toID, specificDirection]);
+            // 移除冗余日志
+            // console.log(`[GRAPH] 添加单向边: ${fromID} --(${specificDirection})--> ${toID}, 权重: ${safeWeight}`);
+        }
+    }
+    // 添加一个点，如果connect中有未记录的点，也要自动补充
+    addPoint(pointID, connect = []) {
+        if (!this.points.has(pointID)) {
+            this.points.set(pointID, { pointID, connect: [] });
+        }
+        const point = this.points.get(pointID);
+        for (const [weight, neighborID, direction] of connect) {
+            // 修复：确保权重为数字
+            const safeWeight = (typeof weight === 'number' && isFinite(weight)) ? weight : 1;
+            // 检查是否已存在这条边，避免重复
+            if (!point.connect.some(([w, id, d]) => w === safeWeight && id === neighborID && d === direction)) {
+                point.connect.push([safeWeight, neighborID, direction]);
+            }
+            // 自动补全邻居点
+            if (!this.points.has(neighborID)) {
+                this.points.set(neighborID, { pointID: neighborID, connect: [] });
+            }
+            // 如果是双向（0），补充对方的connect
+            if (direction === 0) {
+                const neighbor = this.points.get(neighborID);
+                if (!neighbor.connect.some(([w, id, d]) => w === safeWeight && id === pointID && d === 0)) {
+                    neighbor.connect.push([safeWeight, pointID, 0]);
+                }
+            }
+        }
+    }
+
+    // 添加一条边，支持方向
+    addEdge(fromID, toID, weight = 1, direction = 0) {
+        this.addPoint(fromID);
+        this.addPoint(toID);
+        // 修复：确保权重为数字
+        const safeWeight = (typeof weight === 'number' && isFinite(weight)) ? weight : 1;
+        const fromPoint = this.points.get(fromID);
+        if (!fromPoint.connect.some(([w, id, d]) => w === safeWeight && id === toID && d === direction)) {
+            fromPoint.connect.push([safeWeight, toID, direction]);
+        }
+        // 如果是双向，自动补全反向
+        if (direction === 0) {
+            const toPoint = this.points.get(toID);
+            if (!toPoint.connect.some(([w, id, d]) => w === safeWeight && id === fromID && d === 0)) {
+                toPoint.connect.push([safeWeight, fromID, 0]);
+            }
+        }
+    }
+
+    // 更新边的权重
+    updateEdge(fromID, toID, newWeight, direction = 0) {
+        if (this.points.has(fromID)) {
+            const fromPoint = this.points.get(fromID);
+            const edgeIndex = fromPoint.connect.findIndex(([weight, id, d]) => id === toID && d === direction);
+            if (edgeIndex !== -1) {
+                fromPoint.connect[edgeIndex][0] = newWeight;
+            } else {
+                // 如果边不存在，创建新边
+                this.addEdge(fromID, toID, newWeight, direction);
+            }
+        }
+    }
+
+    // A*算法查找最短路径
+    selectPath(fromID, toID) {
+        if (!this.points.has(fromID) || !this.points.has(toID)) return null;
+        if (fromID === toID) return [fromID];
+
+        const openSet = new Set([fromID]);
+        const cameFrom = new Map();
+        const gScore = new Map([[fromID, 0]]);
+        const fScore = new Map([[fromID, this.heuristic(fromID, toID)]]);
+        const closedSet = new Set();
+
+        while (openSet.size > 0) {
+            // 找到fScore最小的点
+            let current = null;
+            let minFScore = Infinity;
+            for (const pointID of openSet) {
+                const score = fScore.get(pointID) ?? Infinity;
+                if (score < minFScore) {
+                    current = pointID;
+                    minFScore = score;
+                }
+            }
+            if (current === null) break;
+
+            openSet.delete(current);
+            closedSet.add(current);
+
+            if (current === toID) {
+                // reconstruct the path
+                const path = [];
+                let temp = current;
+                while (cameFrom.has(temp)) {
+                    path.push(temp);
+                    temp = cameFrom.get(temp);
+                }
+                path.push(fromID);
+                return path.reverse();
+            }
+
+            for (const [weight, neighborID, direction] of this.points.get(current).connect) {
+                // 只考虑允许的方向
+                if (direction === 1 && neighborID !== current) continue; // 只指向自己
+                if (direction === 2 && current !== fromID) continue; // 只指向对方
+                if (closedSet.has(neighborID)) continue;
+
+                const tentativeGScore = (gScore.get(current) || Infinity) + weight;
+                if (!openSet.has(neighborID)) {
+                    openSet.add(neighborID);
+                } else if (tentativeGScore >= (gScore.get(neighborID) || Infinity)) {
+                    continue;
+                }
+
+                cameFrom.set(neighborID, current);
+                gScore.set(neighborID, tentativeGScore);
+                fScore.set(neighborID, tentativeGScore + this.heuristic(neighborID, toID));
+            }
+        }
+        return null;
+    }
+
+    // 获取所有点
+    getAllPoints() {
+        return Array.from(this.points.values());
+    }
+
+    // 启发式函数：简单的常数启发式
+    heuristic(pointID, toID) {
+        return 1; // 简化的启发式函数
+    }
+    existEdge(pointID, neighborID) {
+        const point = this.points.get(pointID);
+        if (!point) {
+            return { exist: false, weight: undefined, type: undefined };
+        }
+        const connectArr = point.connect || [];
+        const found = connectArr.find(([_, id]) => id === neighborID);
+        return {
+            exist: connectArr.some(([_, id]) => id === neighborID),
+            weight: found ? found[0] : undefined,
+            type: found ? found[2] : undefined
+        };
+    }
+    existPoint(pointID) {
+        return { exist: this.points.has(pointID), connect: this.points.get(pointID)?.connect || [] };
+    }
+    deleteEdge(pointID, neighborID) {
+        if (this.existEdge(pointID, neighborID).exist) {
+            this.points.get(pointID).connect = this.points.get(pointID).connect.filter(([_, id]) => id !== neighborID);
+            this.points.get(neighborID).connect = this.points.get(neighborID).connect.filter(([_, id]) => id !== pointID);
+        }
+    }
+    deletePoint(pointID) {
+        if (this.existPoint(pointID).exist) {
+            this.points.delete(pointID);
+        }
+    }
+}
+
+class KVM {
+    constructor() {
+        this.memory = new Map();
+    }
+    get(key) {
+        return this.memory.get(key);
+    }
+    set(key, value) {
+        // 强制保证 value 为数组
+        if (!Array.isArray(value)) {
+            value = value == null ? [] : [value];
+        }
+        this.memory.set(key, value);
+    }
+}
+
+
+
+class Spider {
+    constructor(dir = path.join(__dirname, 'robots'), lemmaCsvPath = path.join(__dirname, 'lemma.csv')) {
+        this.dir = dir;
+        this.lemmaCsvPath = lemmaCsvPath;
+        this.lemmaMap = this.loadLemmaMap();
+    }
+
+    // 加载词形归一化映射表
+    loadLemmaMap() {
+        const lemmaMap = new Map();
+        if (!fs.existsSync(this.lemmaCsvPath)) {
+            console.warn(`[Spider] 未找到词形归一化文件: ${this.lemmaCsvPath}`);
+            return lemmaMap;
+        }
+        const csvContent = fs.readFileSync(this.lemmaCsvPath, 'utf-8');
+        const records = csvParse.parse(csvContent, { skip_empty_lines: true, relax_column_count: true });
+        for (const row of records) {
+            if (row.length < 2) continue;
+            const base = row[0].trim().toLowerCase();
+            for (const form of row) {
+                lemmaMap.set(form.trim().toLowerCase(), base);
+            }
+        }
+        return lemmaMap;
+    }
+
+    // 单词归一化
+    lemmatize(word) {
+        return this.lemmaMap.get(word.toLowerCase()) || word.toLowerCase();
+    }
+
+    // 归一化一组词
+    lemmatizeWords(words) {
+        return words.map(w => this.lemmatize(w));
+    }
+
+    // 优化 Spider.fetchArticles 方法
+    // ...existing code...
+
+    fetchArticles() {
+        console.time('articlesLoad');
+        const articles = [];
+        if (!fs.existsSync(this.dir)) {
+            console.warn(`Spider: 目录不存在: ${this.dir}`);
+            return articles;
+        }
+        const files = fs.readdirSync(this.dir).filter(f => f.endsWith('.txt'));
+        const MAX_ARTICLE_SIZE = 5000000;
+        for (const file of files) {
+            const filePath = path.join(this.dir, file);
+            try {
+                let content = fs.readFileSync(filePath, { encoding: 'utf8', flag: 'r' });
+                if (content.length > MAX_ARTICLE_SIZE) {
+                    content = content.substring(0, MAX_ARTICLE_SIZE);
+                }
+                // 按段落或行分割
+                const rawArticles = content.split(/\r?\n\s*\r?\n/); // 按空行分段
+                for (let article of rawArticles) {
+                    article = article.trim();
+                    if (article.length < 10) continue;
+                    // 不要全局正则替换，分词时再处理
+                    articles.push(article);
+                }
+            } catch (e) {
+                console.warn(`Spider: 读取失败: ${filePath}, ${e.message}`);
+            }
+        }
+        console.timeEnd('articlesLoad');
+        return articles;
+    }
+
+}
+const globalSpider = new Spider();
+global.vocabmanager = new VocabManager(globalSpider);
+class Runtime {
+    static cloneRegistry = new Set();
+    // 运行时负责AI核心的调度、模因转换、信号传递与主流程控制
+    constructor(config = {}) {
+        this.config = config;
+        this.graph = new GraphDB();
+        this.wordGraph = new GraphDB();
+        this.kvm = new KVM();
+
+        this.transformer = null;
+        this.vocabManager = global.vocabmanager;
+        this.spider = new Spider();
+        this.wordAccessLog = new Map();
+        this.initWordGraph();
+        this.forgetTimer = setInterval(() => this.forgetWords(), 350 * 1000);        // 3. 判断是否合并到已有模因
+        this.MAX_MEME_WORDS = 100; // 单个模因最大词数
+        this.MIN_OVERLAP = 2;      // 至少有2个词重叠才允许合并
+        // Runtime类内新增
+        this.activationStats = new Map(); // 记录激活关系
+        this.isclone = false;
+        // 添加系统资源监控
+        this.systemLoad = {
+            lastCpuUsage: process.cpuUsage(),
+            lastCheckTime: Date.now(),
+            currentLoad: 0,
+            batchSizeMultiplier: 1
+        };
+        this.memeBarrier = new memeBarrier(this);
+    }
+    // 添加到Runtime类内部
+    filterStopWords(words) {
+        return words.filter(word => !STOP_WORDS.includes(word.toLowerCase()));
+    }
+
+    // 新增资源监控方法
+    monitorSystemLoad() {
+        const now = Date.now();
+        const cpuUsage = process.cpuUsage();
+
+        // 计算CPU使用率
+        const userDiff = cpuUsage.user - this.systemLoad.lastCpuUsage.user;
+        const sysDiff = cpuUsage.system - this.systemLoad.lastCpuUsage.system;
+        const elapsedMs = now - this.systemLoad.lastCheckTime;
+
+        if (elapsedMs > 0) {
+            // 转换为百分比 (0-100)
+            const cpuPercent = (userDiff + sysDiff) / (elapsedMs * 10); // 粗略计算
+            this.systemLoad.currentLoad = cpuPercent;
+
+            // 动态调整批处理大小
+            if (cpuPercent > 80) {
+                this.systemLoad.batchSizeMultiplier = 0.5; // 负载高，减小批量
+                console.log(`[LOAD] 系统负载高 (${cpuPercent.toFixed(1)}%)，减小批处理大小`);
+            } else if (cpuPercent < 30) {
+                this.systemLoad.batchSizeMultiplier = 2.0; // 负载低，增加批量
+                console.log(`[LOAD] 系统负载低 (${cpuPercent.toFixed(1)}%)，增加批处理大小`);
+            } else {
+                this.systemLoad.batchSizeMultiplier = 1.0; // 负载适中，保持默认
+            }
+
+            // 更新基准值
+            this.systemLoad.lastCpuUsage = cpuUsage;
+            this.systemLoad.lastCheckTime = now;
+        }
+
+        return this.systemLoad.batchSizeMultiplier;
+    }
+    // 清理定时器
+    cleanup() {
+        if (this.forgetTimer) {
+            clearInterval(this.forgetTimer);
+        }
+        if (this.memeBarrier) {
+            this.memeBarrier.stop();
+        }
+    }
+    // Runtime类中添加监控函数
+    monitorMemeSize() {
+        const memes = this.graph.getAllPoints();
+        for (const meme of memes) {
+            const words = this.kvm.get(meme.pointID) || [];
+            if (words.length > this.MAX_MEME_WORDS * 0.8) { // 如果接近最大限制
+           //     console.log(`[MONITOR] 检测到大模因: ${meme.pointID}, 词数: ${words.length}`);
+                this.splitMemeIfNeeded(meme.pointID); // 尝试分裂
+            }
+        }
+    }
+    // 启动自主学习
+    async startSelfLearning(iterations) {
+        // 优先用 config
+        if (iterations === undefined) {
+            iterations = this.config.iteration !== undefined ? this.config.iteration : 5;
+        }
+        console.log('[LEARN] 启动自主学习模块...');
+        const learner = new ReinforcementLearner(this);
+        return await learner.learn(iterations);
+    }
+    // 在每轮信号扩散后，记录激活链
+    recordActivationPath(activatedNodes) {
+        // activatedNodes: 按顺序的被激活节点数组
+        for (let i = 0; i < activatedNodes.length - 1; i++) {
+            const from = activatedNodes[i];
+            const to = activatedNodes[i + 1];
+            const key = `${from}->${to}`;
+            this.activationStats.set(key, (this.activationStats.get(key) || 0) + 1);
+        }
+    }
+
+
+    // 在主循环或REPL后，动态调整模因网络
+    updateAttentionLinks(threshold, decay) {
+        threshold = threshold !== undefined ? threshold : (this.config.threshold !== undefined ? this.config.threshold : 3);
+        decay = decay !== undefined ? decay : (this.config.decay !== undefined ? this.config.decay : 1);
+        for (const [key, count] of this.activationStats.entries()) {
+            const [from, to] = key.split('->');
+            if (count >= threshold) {
+                // 在模因网络中建立/强化 from->to 的边
+                if (!this.graph.existEdge(from, to).exist) {
+                    this.graph.addEdge(from, to, this.graph.existEdge(from, to).weight * 0.8, this.graph.existEdge(from, to).type);
+                } else {
+                    this.graph.updateEdge(from, to, 1, 0);
+                }
+                // 可选：重置计数
+                this.activationStats.set(key, 0);
+            } else if (count <= -decay) {
+                if (this.graph.existEdge(from, to).weight > 5) {
+                    this.graph.deleteEdge(from, to);
+                    this.graph.deleteEdge(to, from);
+                } else {
+                    this.graph.updateEdge(from, to, this.graph.existEdge(from, to).weight * 1.2, this.graph.existEdge(from, to).type);
+                }
+            }
+        }
+    }
+
+    // 记录词语点被访问
+    logWordAccess(word) {
+        const now = Date.now();
+        if (!this.wordAccessLog.has(word)) {
+            this.wordAccessLog.set(word, []);
+        }
+        this.wordAccessLog.get(word).push(now);
+    }
+    registerClone() {
+        Runtime.cloneRegistry.add(this);
+        this.isClone = true;
+        // 不自动销毁
+    }
+
+    dispose() {
+        this.graph.points.clear();
+        this.wordGraph.points.clear();
+        this.kvm.memory.clear();
+        if (this.wordAccessLog) this.wordAccessLog.clear();
+        if (this.forgetTimer) clearInterval(this.forgetTimer);
+        // 其它属性也可清空
+    }
+    forgetWords() {
+        const now = Date.now();
+        const windowMs = 350 * 1000;
+
+        // 只保留窗口内访问
+        for (const [key, times] of this.wordAccessLog.entries()) {
+            const recent = times.filter(t => now - t <= windowMs);
+            this.wordAccessLog.set(key, recent);
+        }
+
+        // 保护：收集所有被KVM引用的词
+        const protectedWords = new Set();
+        for (const [, words] of this.kvm.memory.entries()) {
+            if (Array.isArray(words)) {
+                for (const w of words) protectedWords.add(w);
+            }
+        }
+
+        // 若词表过小，直接跳过遗忘，避免崩塌
+        const vocabSize = this.vocabManager.vocab.length;
+        if (vocabSize < 1000) {
+            console.log('[FORGET] 词表过小，跳过本轮遗忘');
+            return;
+        }
+
+        // 仅对“存在于词图且不在保护集”的词做统计
+        const stats = [];
+        for (const [word, recent] of this.wordAccessLog.entries()) {
+            if (!this.wordGraph.points.has(word)) continue;
+            if (!this.vocabManager.word2idx.has(word)) continue;
+            if (protectedWords.has(word)) continue;
+            stats.push({ word, count: recent.length });
+        }
+        if (stats.length === 0) return;
+
+        stats.sort((a, b) => a.count - b.count);
+
+        // 限制每轮上限，避免快速抽干
+        const maxForgetRate = 0.001; // 改为每轮最多0.1%
+        const n = Math.max(1, Math.floor(stats.length * maxForgetRate));
+
+        const toForget = stats.slice(0, n).map(s => s.word);
+        for (const word of toForget) {
+            this.wordGraph.points.delete(word);
+            this.vocabManager.vocab = this.vocabManager.vocab.filter(w => w !== word);
+            this.vocabManager.updateMappings();
+            this.wordAccessLog.delete(word);
+            console.log(`[FORGET] 淘汰词语点: ${word}`);
+
+            // 同步清理所有模因节点的词表
+            for (const [memeID, words] of this.kvm.memory.entries()) {
+                if (!Array.isArray(words)) continue;
+                const newWords = words.filter(w => w !== word);
+                if (newWords.length !== words.length) {
+                    this.kvm.set(memeID, newWords);
+                    if (newWords.length === 0) {
+                        this.graph.points.delete(memeID);
+                        this.kvm.memory.delete(memeID);
+                        console.log(`[FORGET] 删除空模因节点: ${memeID}`);
+                    }
+                }
+            }
+        }
+
+        // 不在这里调用 runMainLoop，避免循环内触发再次遗忘
+        // this.runMainLoop();
+    }
+    // 修改 initWordGraph 方法
+    initWordGraph() {
+        // 添加一些基本的词语关系，优先使用有方向的连接
+        const relations = [
+            // [词1, 词2, 权重, 方向]
+            // 方向：0=双向, 1=指向自己, 2=指向对方
+
+            // 代词流向关系
+            ['I', 'am', 1, 2],
+            ['you', 'are', 1, 2],
+            ['he', 'is', 1, 2],
+            ['she', 'is', 1, 2],
+            ['they', 'are', 1, 2],
+            ['we', 'are', 1, 2],
+
+            // 动词流向关系
+            ['am', 'a', 1, 2],
+            ['is', 'a', 1, 2],
+            ['are', 'a', 1, 2],
+            ['like', 'to', 1, 2],
+            ['want', 'to', 1, 2],
+
+            // 形容词关系（可以保留部分双向）
+            ['good', 'happy', 1, 0],
+            ['bad', 'sad', 1, 0],
+
+            // 名词关系（类别上的）
+            ['apple', 'fruit', 1, 2],
+            ['orange', 'fruit', 1, 2]
+        ];
+
+        for (const [word1, word2, weight, direction] of relations) {
+            // 根据方向值选择边类型
+            if (direction === 0) {
+                this.wordGraph.addBidirectionalEdge(word1, word2, weight);
+            } else {
+                this.wordGraph.addDirectionalEdge(word1, word2, weight, direction);
+            }
+        }
+    }
+
+    // 载入/保存模因网络
+    loadGraph(data) {
+        data.forEach(point => this.graph.addPoint(point.pointID, point.connect));
+    }
+
+    saveGraph() {
+        return this.graph.getAllPoints();
+    }
+
+    // 信号在模因网络中的传递
+    propagateSignal(startID, strength, decayK = 1) {
+        let active = [{ id: startID, value: strength }];
+        const visited = new Set();
+        const activatedOrder = [];
+        const MAX_VISITS = 5000;
+        let visitCount = 0;
+
+        while (active.length > 0 && visitCount < MAX_VISITS) {
+            const next = [];
+            for (const { id, value } of active) {
+                if (value <= 0 || visited.has(id)) continue;
+                visited.add(id);
+                visitCount++;
+                activatedOrder.push(id);
+
+                // 仅在是“词”时记录访问，避免把模因ID写入词访问日志
+                if (this.wordGraph.points.has(id)) {
+                    this.logWordAccess(id);
+                }
+
+                const point = this.graph.points.get(id);
+                if (point) {
+                    const MAX_NEIGHBORS = 50;
+                    const neighbors = point.connect.slice(0, MAX_NEIGHBORS);
+                    for (const [weight, neighborID] of neighbors) {
+                        if (!visited.has(neighborID)) {
+                            next.push({ id: neighborID, value: value - decayK * weight });
+                        }
+                    }
+                }
+            }
+            active = next;
+        }
+        if (visitCount >= MAX_VISITS) {
+            console.log(`[WARNING] propagateSignal 达到节点访问上限(${MAX_VISITS})，可能未完全传播`);
+        }
+        return activatedOrder;
+    }
+    async generateResponseWithMemes(inputWords, maxLen) {
+        maxLen = maxLen !== undefined ? maxLen : (this.config.maxLen !== undefined ? this.config.maxLen : 16);
+        // 1. 计算每个模因的覆盖率，选出所有被激活的模因
+        const memeStats = [];
+        for (const meme of this.graph.getAllPoints()) {
+            const memeWords = this.kvm.get(meme.pointID) || [];
+            let overlap = 0;
+            for (const word of inputWords) {
+                if (memeWords.includes(word)) overlap++;
+            }
+            let coverage = memeWords.length > 0 ? overlap / memeWords.length : 0;
+            memeStats.push({ meme, coverage });
+        }
+        // 只选覆盖率>0的模因
+        const activated = memeStats.filter(m => m.coverage > 0);
+        if (activated.length === 0) return '（没有相关记忆）';
+
+        // 2. 多源扩散，信号强度=覆盖率
+        const startIDs = activated.map(m => m.meme.pointID);
+        const strengths = activated.map(m => m.coverage);
+        const signalMap = this.propagateSignalMultiSource(startIDs, strengths, 0.5, 2);
+
+        // 3. 按信号强度排序，收集词表
+        const sortedMemes = Array.from(signalMap.entries())
+            .sort((a, b) => b[1] - a[1])
+            .map(([id]) => id);
+
+        let contextWords = [];
+        for (const memeID of sortedMemes) {
+            const words = this.kvm.get(memeID) || [];
+            contextWords.push(...words);
+            if (contextWords.length >= maxLen) break;
+        }
+        contextWords = Array.from(new Set(contextWords)).slice(0, maxLen);
+
+        if (contextWords.length === 0) return '（没有相关记忆）';
+        return contextWords.join(' ');
+    }
+
+    // 处理自然语言输入（wordsArr为分好词的数组）
+    // 修改 processInput 函数，创建单向连接而非双向连接
+    processInput(wordsArr, { addNewWords = true } = {}) {
+        wordsArr = this.filterStopWords(wordsArr);
+        if (wordsArr.length === 0) { console.log('[FILTER] 输入全为停用词，已全部过滤'); return; }
+      //  console.log('Processing input:', wordsArr);
+        // 批量处理新词添加
+        if (addNewWords) {
+            // 一次性检查哪些词不在词表中
+            const newWords = wordsArr.filter(word => !this.wordGraph.points.has(word));
+
+            // 批量添加新词到词表
+            for (const word of newWords) {
+                this.vocabManager.addWord(word);
+                this.wordGraph.addPoint(word, []);
+            }
+
+            // 批量添加词语访问记录
+            const now = Date.now();
+            for (const word of wordsArr) {
+                if (!this.wordAccessLog.has(word)) {
+                    this.wordAccessLog.set(word, []);
+                }
+                this.wordAccessLog.get(word).push(now);
+            }
+
+            // 批量创建词语之间的有向连接
+            if (wordsArr.length > 1) {
+                // 优化 addDirectionalEdge 调用
+                this._batchAddDirectionalEdges(wordsArr);
+            }
+        }
+        // 添加新词到词表和词图
+        for (const word of wordsArr) {
+            if (addNewWords) {
+                this.vocabManager.addWord(word);
+                if (!this.wordGraph.points.has(word)) {
+                    this.wordGraph.addPoint(word, []);
+                }
+            }
+            this.logWordAccess(word); // 记录访问
+        }
+
+        // 创建词语之间的有向连接 (按顺序连接)
+        if (addNewWords && wordsArr.length > 1) {
+            for (let i = 0; i < wordsArr.length - 1; i++) {
+                // 从前一个词指向后一个词 (方向:2表示指向对方)
+                this.wordGraph.addDirectionalEdge(wordsArr[i], wordsArr[i + 1], 1, 2);
+            }
+        }
+
+        // 寻找最近的模因
+        let minDistance = Infinity;
+        let minMemeID = null;
+
+        for (const meme of this.graph.getAllPoints()) {
+            const memeWords = this.kvm.get(meme.pointID) || [];
+            let totalDist = 0;
+            let count = 0;
+
+            for (const word of wordsArr) {
+                let wordDist = Infinity;
+                for (const memeWord of memeWords) {
+                    if (word === memeWord) {
+                        wordDist = 0;
+                        break;
+                    }
+                    const path = this.wordGraph.selectPath(word, memeWord);
+                    if (path) {
+                        wordDist = Math.min(wordDist, path.length - 1);
+                    }
+                }
+                if (wordDist < Infinity) {
+                    totalDist += wordDist;
+                    count++;
+                }
+            }
+
+            let avgDist = count > 0 ? totalDist / count : Infinity;
+            if (avgDist < minDistance) {
+                minDistance = avgDist;
+                minMemeID = meme.pointID;
+            }
+        }
+
+        if (minDistance < Infinity && minDistance <= 1) {
+            // 合并到现有模因或创建新模因...
+            const memeWords = this.kvm.get(minMemeID) || [];
+            const overlap = wordsArr.filter(w => memeWords.includes(w)).length;
+            if (overlap >= this.MIN_OVERLAP && memeWords.length + wordsArr.length <= this.MAX_MEME_WORDS) {
+                this.kvm.set(minMemeID, Array.from(new Set([...memeWords, ...wordsArr])));
+         ///       console.log(`Merged to existing meme: ${minMemeID}`);
+            } else {
+                // 创建新模因，使用有向连接
+                const newID = 'meme_' + Date.now();
+                this.graph.addPoint(newID, []);
+                this.kvm.set(newID, wordsArr);
+
+                // 单向连接到最近的模因 (方向:2表示指向对方)
+                if (minMemeID) {
+                    this.graph.addDirectionalEdge(newID, minMemeID, minDistance, 2);
+             //       console.log(`[LINK] 新模因 ${newID} 单向连接到最近模因 ${minMemeID}`);
+                }
+            //    console.log(`Created new meme: ${newID}`);
+            }
+        } else {
+            // 创建新模因
+            const newID = 'meme_' + Date.now();
+            this.graph.addPoint(newID, []);
+            this.kvm.set(newID, wordsArr);
+
+            // 如果有较近的模因，仍然创建单向连接
+            if (minMemeID) {
+                this.graph.addDirectionalEdge(newID, minMemeID, Math.min(minDistance, 5), 2);
+          //      console.log(`[LINK] 新模因 ${newID} 单向连接到最近模因 ${minMemeID}`);
+            }
+        //    console.log(`Created new meme: ${newID}`);
+        }
+    }
+    // 新增批量添加边的辅助方法
+    _batchAddDirectionalEdges(words) {
+        // 预先确保所有点都存在
+        for (const word of words) {
+            if (!this.wordGraph.points.has(word)) {
+                this.wordGraph.addPoint(word, []);
+            }
+        }
+
+        // 批量添加边
+        for (let i = 0; i < words.length - 1; i++) {
+            const fromWord = words[i];
+            const toWord = words[i + 1];
+            const fromPoint = this.wordGraph.points.get(fromWord);
+
+            // 检查是否已存在这条边
+            if (!fromPoint.connect.some(([_, id, d]) => id === toWord && d === 2)) {
+                fromPoint.connect.push([1, toWord, 2]);
+            }
+        }
+    }
+    // 从Spider加载并构建词表
+    buildVocabFromSpider() {
+        return this.vocabManager.buildVocabFromSpider(this.spider);
+    }
+    // Runtime类内
+    // ...existing code...
+    /**
+     * 多源信号扩散（优化版，无防环，充分利用单向路线，信号可多次叠加）
+     * 支持信号融合、动态权重、阻塞式高并发保护、可追踪激活路径
+     * @param {Array<string>} startIDs - 多个起点ID
+     * @param {Array<number>} strengths - 各起点信号强度
+     * @param {number} decayK - 衰减系数
+     * @param {number} maxStep - 最大扩散步数
+     * @param {Object} options - 可选参数
+     *        options.maxActiveNodes: 每步最大活跃节点数
+     *        options.minSignal: 信号强度低于此值不再传播
+     *        options.trackPath: 是否记录激活路径
+     * @returns {Object|Map} { signalMap, activationPaths } 或 signalMap
+     */
+    propagateSignalMultiSource(startIDs, strengths, decayK, maxStep, options = {}) {
+        decayK = decayK !== undefined ? decayK : (this.config.decayK !== undefined ? this.config.decayK : 1);
+        maxStep = maxStep !== undefined ? maxStep : (this.config.maxStep !== undefined ? this.config.maxStep : 10);
+        const maxActiveNodes = options.maxActiveNodes || 5000;
+        const minSignal = options.minSignal || 0.01;
+        const trackPath = options.trackPath || false;
+
+        // 节点信号累加表
+        const signalMap = new Map();
+        // 路径追踪表（可选）
+        const activationPaths = trackPath ? new Map() : null;
+
+        // 初始化活跃队列，每个元素{id, value, from}
+        let active = startIDs.map((id, i) => ({
+            id,
+            value: strengths[i],
+            from: null // 起点无前驱
+        }));
+
+        let step = 0;
+
+        while (active.length > 0 && step < maxStep) {
+            // 1. 限制活跃节点数，优先保留信号强的
+            if (active.length > maxActiveNodes) {
+                active.sort((a, b) => b.value - a.value);
+                active = active.slice(0, maxActiveNodes);
+                console.log(`[LIMIT] 多源扩散活跃节点数已限制为 ${maxActiveNodes}`);
+            }
+
+            const next = [];
+            for (const { id, value, from } of active) {
+                if (value < minSignal) continue;
+
+                // 信号融合：累加到signalMap
+                signalMap.set(id, (signalMap.get(id) || 0) + value);
+
+                // 路径追踪
+                if (trackPath) {
+                    if (!activationPaths.has(id)) activationPaths.set(id, []);
+                    if (from !== null) activationPaths.get(id).push(from);
+                }
+
+                // 传播到邻居（不防环，允许信号多次叠加）
+                const point = this.graph.points.get(id);
+                if (point) {
+                    // 限制每个节点最多处理的邻居数量
+                    const MAX_NEIGHBORS = 30;
+                    const neighbors = point.connect.slice(0, MAX_NEIGHBORS);
+
+                    for (const [weight, neighborID] of neighbors) {
+                        // 信号可按边权重调整（如weight越小越容易传播）
+                        const nextValue = value - decayK * weight;
+                        if (nextValue >= minSignal) {
+                            next.push({
+                                id: neighborID,
+                                value: nextValue,
+                                from: id
+                            });
+                        }
+                    }
+                }
+            }
+            active = next;
+            step++;
+        }
+
+        if (trackPath) {
+            return { signalMap, activationPaths };
+        }
+        return signalMap;
+    }
+    // ...existing code...
+
+    // 主循环：持续归纳和信号传递
+    // Runtime类内
+    // Runtime类内
+    // Runtime类内
+    // 添加到Runtime类
+    checkMemoryUsage() {
+        const memUsage = process.memoryUsage();
+        const usedHeapPct = memUsage.heapUsed / memUsage.heapTotal * 100;
+        const usedRssPct = memUsage.rss / (1024 * 1024 * 1024) * 100; // 占用物理内存百分比(假设8GB)
+
+        console.log(`[MEMORY] Heap: ${(memUsage.heapUsed / 1024 / 1024).toFixed(1)}MB/${(memUsage.heapTotal / 1024 / 1024).toFixed(1)}MB (${usedHeapPct.toFixed(1)}%), RSS: ${(memUsage.rss / 1024 / 1024).toFixed(1)}MB`);
+
+        // 如果堆内存或RSS过高，执行紧急GC
+        if (usedHeapPct > 85 || usedRssPct > 80) {
+            console.log('[MEMORY] 内存使用率过高，执行紧急清理');
+            this.emergencyMemoryCleanup();
+            return false; // 表示内存紧张
+        }
+        return true; // 内存正常
+    }
+
+    // 紧急内存清理
+    emergencyMemoryCleanup() {
+        // 清理可丢弃的缓存
+        this.wordAccessLog = new Map([...this.wordAccessLog.entries()]
+            .slice(-1000)); // 只保留最近1000条
+        // 清理模因阻断系统的历史记录
+        if (this.memeBarrier && this.memeBarrier.suspiciousMemesHistory) {
+            // 只保留最近的记录
+            for (const [memeID, history] of this.memeBarrier.suspiciousMemesHistory.entries()) {
+                if (history.length > 10) {
+                    this.memeBarrier.suspiciousMemesHistory.set(memeID, history.slice(-5));
+                }
+            }
+        }
+        // 强制GC (如果环境支持)
+        if (global.gc) {
+            global.gc();
+            console.log('[MEMORY] 已触发垃圾回收');
+        } else {
+            console.log('[MEMORY] 垃圾回收不可用，请使用 --expose-gc 启动');
+        }
+    }
+    async runMainLoop() {
+        this.memeBarrier.start();
+        let running = true;
+        let tick = 0;
+        console.log('Starting main loop...');
+
+        while (running) {
+            // 1. 内存与系统负载监控
+            const memoryOk = this.checkMemoryUsage();
+            if (!memoryOk) {
+                console.log('[LOOP] 内存压力大，本轮循环减少处理量');
+                // 可以跳过此轮或减少处理量
+            }
+            // 动态调整批处理大小
+            const loadMultiplier = this.monitorSystemLoad();
+            const BATCH_SIZE = Math.max(50, Math.floor(100 * loadMultiplier));
+
+            // 2. 随机激活一个模因节点并信号扩散
+            const allMemes = this.graph.getAllPoints();
+            if (allMemes.length === 0) {
+                console.log('No memes found, breaking loop');
+                break;
+            }
+            const startMeme = allMemes[Math.floor(Math.random() * allMemes.length)];
+            let activatedNodes = this.propagateSignal(startMeme.pointID, 10, 1) || [];
+            this.recordActivationPath(activatedNodes);
+
+            // 3. 自动归纳/合并模因（多线程并行批处理）
+            let memesToDelete = new Set();
+            const results = [];
+
+            for (let i = 0; i < allMemes.length; i++) {
+                const memeA = allMemes[i];
+                if (memesToDelete.has(memeA.pointID)) continue;
+                const wordsA = this.kvm.get(memeA.pointID) || [];
+
+                // 分批处理j
+                for (let jStart = i + 1; jStart < allMemes.length; jStart += BATCH_SIZE) {
+                    const batchEnd = Math.min(jStart + BATCH_SIZE, allMemes.length);
+                    const batchTasks = [];
+
+                    for (let j = jStart; j < batchEnd; j++) {
+                        const memeB = allMemes[j];
+                        if (memesToDelete.has(memeB.pointID)) continue;
+                        const wordsB = this.kvm.get(memeB.pointID) || [];
+                        batchTasks.push(
+                            safePoolExec('calcMemeDistance', [{ wordsA, wordsB }], { avgDist: Infinity, overlap: 0 })
+                                .then(({ avgDist, overlap }) => ({ i, j, avgDist, overlap }))
+                        );
+                    }
+
+                    // 等待当前批次完成
+                    const batchResults = await Promise.all(batchTasks);
+                    results.push(...batchResults);
+
+                    // 处理结果
+                    for (const { i, j, avgDist, overlap } of batchResults) {
+                        this._processMemeComparisonResult(
+                            allMemes[i], allMemes[j], avgDist, overlap, memesToDelete
+                        );
+                    }
+                }
+            }
+
+            // 4. 其它AI流程
+            const activeMemes = this.graph.getAllPoints().length;
+            console.log(`Tick ${tick}: ${activeMemes} memes active`);
+
+            // 5. 集成注意力机制与模因监控
+            this.updateAttentionLinks(3, 1);
+            this.monitorMemeSize();
+
+            // 6. 控制循环退出条件
+            tick++;
+            if (tick >= 10) running = false;
+        }
+
+        console.log('Main loop ended');
+    }
+
+    // 新增辅助函数，处理模因比较结果
+    // Runtime类内
+    _processMemeComparisonResult(memeA, memeB, avgDist, overlap, memesToDelete) {
+        if (!memeA || !memeB) return;
+        if (memesToDelete.has(memeA.pointID) || memesToDelete.has(memeB.pointID)) return;
+
+        const wordsA = this.kvm.get(memeA.pointID) || [];
+        const wordsB = this.kvm.get(memeB.pointID) || [];
+
+        // 距离小于等于1则合并
+        if (
+            avgDist <= 1 &&
+            wordsA.length + wordsB.length <= this.MAX_MEME_WORDS &&
+            overlap >= this.MIN_OVERLAP &&
+            (wordsA.length < this.MAX_MEME_WORDS * 0.8 && wordsB.length < this.MAX_MEME_WORDS * 0.8) &&
+            (overlap / Math.min(wordsA.length, wordsB.length) >= 0.3)
+        ) {
+            // 合并词汇
+            this.kvm.set(memeA.pointID, Array.from(new Set([...wordsA, ...wordsB])));
+
+            // --- 合并边 ---
+            // 1. 将所有指向 memeB 的边重定向到 memeA
+            for (const point of this.graph.getAllPoints()) {
+                for (let edge of point.connect) {
+                    if (edge[1] === memeB.pointID) {
+                        edge[1] = memeA.pointID;
+                    }
+                }
+            }
+            // 2. 将 memeB 的出边合并到 memeA（避免重复）
+            const memeBPoint = this.graph.points.get(memeB.pointID);
+            const memeAPoint = this.graph.points.get(memeA.pointID);
+            if (memeBPoint && memeAPoint) {
+                for (const edge of memeBPoint.connect) {
+                    if (!memeAPoint.connect.some(e => e[1] === edge[1] && e[2] === edge[2])) {
+                        memeAPoint.connect.push([...edge]);
+                    }
+                }
+            }
+
+            // 3. 删除 memeB 节点
+            this.graph.points.delete(memeB.pointID);
+            this.kvm.memory.delete(memeB.pointID);
+            memesToDelete.add(memeB.pointID);
+
+       //     console.log(`Merged memes: ${memeA.pointID} <- ${memeB.pointID}`);
+            // 合并后立即尝试分裂
+            this.splitMemeIfNeeded(memeA.pointID);
+        } else {
+            // 不合并，但有重合单词，且距离大于1且小于Infinity
+            if (
+                overlap > 0 &&
+                avgDist > 1 &&
+                avgDist < Infinity
+            ) {
+                // 检查是否已有单向边
+                const existAtoB = this.graph.existEdge(memeA.pointID, memeB.pointID);
+                const existBtoA = this.graph.existEdge(memeB.pointID, memeA.pointID);
+
+                // 如果没有双向边，则添加双向边
+                if (!(existAtoB.exist && existAtoB.type === 0) && !(existBtoA.exist && existBtoA.type === 0)) {
+                    this.graph.addBidirectionalEdge(memeA.pointID, memeB.pointID, avgDist);
+            //        console.log(`[LINK] 添加双向边: ${memeA.pointID} <-> ${memeB.pointID} (avgDist=${avgDist})`);
+                }
+            }
+        }
+
+        // 更新模因之间的边权重为距离
+        this.graph.updateEdge(memeA.pointID, memeB.pointID, avgDist, 0);
+    }
+    // Runtime类内
+    splitMemeIfNeeded(memeID) {
+        const words = this.kvm.get(memeID) || [];
+        if (words.length <= 5) return; // 太小不分裂
+
+        // 强制分裂：超过阈值直接分裂
+        if (words.length > this.MAX_MEME_WORDS * 0.8) {
+            // 优化分裂算法，减少循环复杂度
+            const chunkSize = Math.ceil(this.MAX_MEME_WORDS / 2.5);
+            const chunksCount = Math.ceil(words.length / chunkSize);
+
+            // 预分配ID，减少循环中的时间戳计算
+            const newIDs = Array(chunksCount).fill().map(() =>
+                'meme_' + Date.now() + '_' + Math.floor(Math.random() * 10000)
+            );
+
+            // 批量创建新模因
+            for (let i = 0; i < chunksCount; i++) {
+                const chunk = words.slice(i * chunkSize, (i + 1) * chunkSize);
+                if (chunk.length > 1) {
+                    const newID = newIDs[i];
+                    this.graph.addPoint(newID, []);
+                    this.kvm.set(newID, chunk);
+            //        console.log(`[SPLIT-FORCE] 新建模因: ${newID} 词数: ${chunk.length}`);
+                }
+            }
+
+            // 删除原模因
+            this.graph.points.delete(memeID);
+            this.kvm.memory.delete(memeID);
+         //   console.log(`[SPLIT-FORCE] 删除原模因: ${memeID}`);
+            return;
+        }
+
+        // 构建词语子图
+        const subgraph = new Map();
+        for (const word of words) {
+            const connects = [];
+            const point = this.wordGraph.points.get(word);
+            if (point) {
+                for (const [, neighbor] of point.connect) {
+                    if (words.includes(neighbor)) {
+                        connects.push(neighbor);
+                    }
+                }
+            }
+            subgraph.set(word, connects);
+        }
+
+        // 寻找连通分量，使用BFS算法而非递归，避免栈溢出
+        const visited = new Set();
+        const components = [];
+        for (const word of words) {
+            if (visited.has(word)) continue;
+            const queue = [word];
+            const comp = [];
+            visited.add(word);
+            while (queue.length > 0) {
+                const w = queue.shift();
+                comp.push(w);
+                for (const n of subgraph.get(w) || []) {
+                    if (!visited.has(n)) {
+                        visited.add(n);
+                        queue.push(n);
+                    }
+                }
+            }
+            if (comp.length > 0) components.push(comp);
+        }
+
+        // 判断是否需要分裂
+        if (components.length > 1 && components.some(c => c.length >= 5)) {
+            // 分裂
+            for (const comp of components) {
+                if (comp.length < 2) continue; // 太小不建新节点
+                const newID = 'meme_' + Date.now() + '_' + Math.floor(Math.random() * 10000);
+                this.graph.addPoint(newID, []);
+                this.kvm.set(newID, comp);
+            //    console.log(`[SPLIT] 新建模因: ${newID} 词数: ${comp.length}`);
+            }
+            // 删除原节点
+            this.graph.points.delete(memeID);
+            this.kvm.memory.delete(memeID);
+        //    console.log(`[SPLIT] 删除原模因: ${memeID}`);
+        }
+    }
+}
+function safePoolExec(method, args, fallback) {
+    if (isShuttingDown) return Promise.resolve(fallback);
+    try {
+        return pool.exec(method, args);
+    } catch (e) {
+        if (String(e && e.message).toLowerCase().includes('terminated')) {
+            return Promise.resolve(fallback);
+        }
+        throw e;
+    }
+}
+// 关联层：分析模因层边的关系并形成抽象模式
+class AssociationLayer {
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.patterns = []; // 存储发现的模因边关系模式
+    }
+
+    // 识别模因层的边关系模式
+    identifyPatterns() {
+        const memes = this.runtime.graph.getAllPoints();
+        // 边关系模式：记录权重、连接度分布等
+        const edgePatterns = new Map();
+        const connectivityPatterns = new Map(); // 模因连接度分布
+
+        // 分析边权重模式
+        for (const meme of memes) {
+            // 记录此模因的连接度
+            const connectivity = meme.connect.length;
+            connectivityPatterns.set(
+                connectivity,
+                (connectivityPatterns.get(connectivity) || 0) + 1
+            );
+
+            // 记录边权重模式
+            for (const [weight, neighborID] of meme.connect) {
+                const key = `${weight.toFixed(2)}`;
+                edgePatterns.set(key, (edgePatterns.get(key) || 0) + 1);
+
+                // 获取连接两端模因的词汇量
+                const sourceWords = this.runtime.kvm.get(meme.pointID) || [];
+                const targetWords = this.runtime.kvm.get(neighborID) || [];
+
+                // 记录"词汇量比例-边权重"关系
+                const sizeRatio = Math.max(sourceWords.length, targetWords.length) /
+                    (Math.min(sourceWords.length, targetWords.length) || 1);
+                const ratioKey = `ratio:${sizeRatio.toFixed(1)}-weight:${weight.toFixed(2)}`;
+                edgePatterns.set(ratioKey, (edgePatterns.get(ratioKey) || 0) + 1);
+            }
+        }
+
+        // 提取最常见模式
+        const commonEdgePatterns = Array.from(edgePatterns.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10); // 取前10种最常见边模式
+
+        const connectivityDistribution = Array.from(connectivityPatterns.entries())
+            .sort((a, b) => a[0] - b[0]); // 按连接度排序
+
+        this.patterns = {
+            edgeWeights: commonEdgePatterns,
+            connectivity: connectivityDistribution
+        };
+
+        console.log(`[ASSOCIATION] 识别出${commonEdgePatterns.length}种边模式`);
+        return this.patterns;
+    }
+    // 继续AssociationLayer类
+
+    // ...前面的代码...
+
+    // 创建系统副本
+    async cloneSystem() {
+        console.log('[CLONE] 创建系统副本');
+        const clone = new Runtime();
+        clone.registerClone();
+
+        try {
+            // 1. 确保Spider实例共享
+            clone.spider = this.runtime.spider;
+
+            // 2. 复制词表（确保顺序一致）
+            clone.vocabManager.vocab = [...this.runtime.vocabManager.vocab];
+            clone.vocabManager.updateMappings();
+
+            // 3. 复制词语网络
+            console.log('[CLONE] 开始复制词语网络...');
+            for (const [key, value] of this.runtime.wordGraph.points.entries()) {
+                clone.wordGraph.addPoint(key, Array.isArray(value.connect) ?
+                    value.connect.map(conn => [...conn]) : []);
+            }
+
+            // 4. 复制模因网络
+            console.log('[CLONE] 开始复制模因网络...');
+            for (const [key, value] of this.runtime.graph.points.entries()) {
+                clone.graph.addPoint(key, Array.isArray(value.connect) ?
+                    value.connect.map(conn => [...conn]) : []);
+            }
+
+            // 5. 复制KVM - 确保一致性和类型
+            console.log('[CLONE] 开始复制KVM...');
+            let nonEmptyCount = 0;
+            let totalWordCount = 0;
+
+            for (const [key, value] of this.runtime.kvm.memory.entries()) {
+                // 严格规范化所有词汇
+                if (Array.isArray(value)) {
+                    // 确保数组中每个元素都是字符串且归一化
+                    const normalizedWords = value.map(word =>
+                        typeof word === 'string' ? word.toLowerCase().trim() : String(word)
+                    );
+
+                    // 应用词形归一化
+                    const lemmatizedWords = clone.spider.lemmatizeWords(normalizedWords);
+                    clone.kvm.set(key, lemmatizedWords);
+
+                    if (lemmatizedWords.length > 0) {
+                        nonEmptyCount++;
+                        totalWordCount += lemmatizedWords.length;
+                    }
+                } else if (value != null) {
+                    // 非数组值转换为单元素数组
+                    const singleWord = String(value).toLowerCase().trim();
+                    const lemmatizedWord = clone.spider.lemmatize(singleWord);
+                    clone.kvm.set(key, [lemmatizedWord]);
+
+                    nonEmptyCount++;
+                    totalWordCount++;
+                } else {
+                    // null或undefined情况，设为空数组
+                    clone.kvm.set(key, []);
+                }
+            }
+
+            console.log(`[CLONE] KVM复制完成: ${nonEmptyCount}个非空模因，${totalWordCount}个词语`);
+
+            // 6. 复制其他配置和参数
+            console.log('[CLONE] 开始复制词表和其他属性...');
+            clone.MAX_MEME_WORDS = this.runtime.MAX_MEME_WORDS;
+            clone.MIN_OVERLAP = this.runtime.MIN_OVERLAP;
+            clone.config = { ...this.runtime.config };
+
+            console.log('[CLONE] 系统副本创建完成');
+            return clone;
+        } catch (error) {
+            console.error('[CLONE ERROR]', error);
+            return clone;
+        }
+    }    // 将模式应用到系统副本
+
+    applyPatternsToClone(systemClone) {
+        console.log('[CLONE] 应用关系模式到副本');
+
+        // 在开始修改前进行KVM内容检查
+        let wordCount = 0;
+        let nonEmptyMemes = 0;
+        for (const [memeID, words] of systemClone.kvm.memory.entries()) {
+            if (Array.isArray(words) && words.length > 0) {
+                wordCount += words.length;
+                nonEmptyMemes++;
+            }
+        }
+        console.log(`[CLONE] 克隆系统KVM检查: ${nonEmptyMemes}个非空模因, ${wordCount}个词语`);
+
+        // 如果词汇数为0，说明克隆过程有问题，尝试重新复制KVM
+        if (wordCount === 0) {
+            console.log('[CLONE] 克隆系统KVM为空，重新复制KVM数据');
+            for (const [key, value] of this.runtime.kvm.memory.entries()) {
+                systemClone.kvm.set(key, Array.isArray(value) ? [...value] : [String(value)]);
+            }
+        }
+
+        const cloneMemes = systemClone.graph.getAllPoints();
+        if (cloneMemes.length === 0) return systemClone;
+        // 防御性处理
+        if (!this.patterns || !Array.isArray(this.patterns.edgeWeights)) {
+            console.warn('[CLONE] 未检测到有效的边模式，跳过关系模式应用');
+            return systemClone;
+        }
+        // 限制修改范围在10%以内
+        const modifyLimit = Math.max(1, Math.floor(cloneMemes.length * 0.1));
+        let modified = 0;
+
+        for (const [patternKey, frequency] of this.patterns.edgeWeights) {
+            if (modified >= modifyLimit) break;
+
+            if (!patternKey.includes('ratio:')) {
+                const weight = parseFloat(patternKey);
+                if (isNaN(weight)) continue;
+
+                const targetCount = Math.ceil(frequency / 10);
+                for (let i = 0; i < targetCount && modified < modifyLimit; i++) {
+                    const randomIdx = Math.floor(Math.random() * cloneMemes.length);
+                    const meme = cloneMemes[randomIdx];
+
+                    if (meme.connect.length > 0) {
+                        const connIdx = Math.floor(Math.random() * meme.connect.length);
+                        const oldWeight = meme.connect[connIdx][0];
+                        const direction = meme.connect[connIdx][2];
+
+                        const newWeight = Math.min(5, Math.max(0.1, isFinite(weight) ?
+                            weight + (Math.random() - 0.5) * 0.5 : Math.random() * 2 + 0.5));
+                        meme.connect[connIdx][0] = newWeight;
+                        meme.connect[connIdx][2] = direction;
+
+      //                  console.log(`[CLONE] 修改边权重: ${meme.pointID}->${meme.connect[connIdx][1]}, ${oldWeight}->${newWeight.toFixed(2)}, 保留方向: ${direction}`);
+                        modified++;
+                    }
+                }
+            }
+        }
+
+        return systemClone;
+    }
+}
+// 强化学习模块
+class ReinforcementLearner {
+    constructor(runtime, testArticlesPath = path.join(__dirname, 'tests')) {
+        this.runtime = runtime;
+        this.testArticlesPath = testArticlesPath;
+        this.associationLayer = new AssociationLayer(runtime);
+    }
+    updateRuntime(newRuntime) {
+        if (this.runtime) {
+            this.runtime.cleanup();
+        }
+
+        this.runtime = newRuntime;
+
+        // 确保词表映射是最新的
+        this.runtime.vocabManager.updateMappings();
+
+        // 确保Spider实例一致
+        if (global.ctrlA && global.ctrlA.runtime && global.ctrlA.runtime.spider) {
+            this.runtime.spider = global.ctrlA.runtime.spider;
+        }
+
+        // 进行词汇一致性检查
+        this._validateVocabulary();
+
+        console.log(`[CONTROLLER] Runtime已更新，词汇表大小: ${this.runtime.vocabManager.vocab.length}`);
+    }
+    // 添加辅助方法：词汇一致性检查
+    _validateVocabulary() {
+        // 抽查KVM中的词是否在词表中
+        let missingWords = 0;
+        const sampleSize = Math.min(100, this.runtime.kvm.memory.size);
+        const sampleMemes = Array.from(this.runtime.kvm.memory.keys()).slice(0, sampleSize);
+
+        for (const memeID of sampleMemes) {
+            const words = this.runtime.kvm.get(memeID) || [];
+            if (!Array.isArray(words)) {
+                console.warn(`[CONTROLLER] 模因${memeID}的KVM值不是数组`);
+                this.runtime.kvm.set(memeID, []);
+                continue;
+            }
+
+            for (const word of words) {
+                if (!this.runtime.vocabManager.word2idx.has(word)) {
+                    this.runtime.vocabManager.addWord(word);
+                    missingWords++;
+                }
+            }
+        }
+
+        if (missingWords > 0) {
+            console.log(`[CONTROLLER] 已将${missingWords}个缺失词添加到词表`);
+            this.runtime.vocabManager.updateMappings();
+        }
+    }
+    // 加载测试文章
+    loadTestArticles() {
+        const articles = [];
+        if (!fs.existsSync(this.testArticlesPath)) {
+            console.warn(`[RL] 测试目录不存在: ${this.testArticlesPath}`);
+            return articles;
+        }
+
+        const files = fs.readdirSync(this.testArticlesPath).filter(f => f.endsWith('.txt'));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(this.testArticlesPath, file), 'utf-8');
+                articles.push(content);
+            } catch (e) {
+                console.warn(`[RL] 读取失败: ${file}`);
+            }
+        }
+        return articles;
+    }
+
+    // 评估系统
+    // ReinforcementLearner类内
+    evaluateSystem(system, article) {
+        // 1. 标准化处理输入文章
+        const cleaned = article.toLowerCase().replace(/[^a-z\s]/g, ' ');
+        const allWords = cleaned.split(/\s+/).filter(w => w.length > 0);
+
+        // 关键：使用Spider进行词形还原
+        const lemmatizedWords = system.spider ? system.spider.lemmatizeWords(allWords) : allWords;
+        const uniqueWords = Array.from(new Set(lemmatizedWords));
+
+        if (uniqueWords.length === 0) return 0;
+
+        // 屏蔽高频词
+        const stopWords = ['be', 'for', 'the', 'and', 'a', 'an', 'of', 'in', 'to', 'that', 'it', 'with', 'is', 'was', 'as', 'on'];
+        const filteredWords = uniqueWords.filter(word => !stopWords.includes(word));
+
+        if (filteredWords.length === 0) return 0; // 全是停用词，直接返回0
+
+        // 取10%的词作为输入（至少1个）
+        const inputCount = Math.max(1, Math.floor(filteredWords.length * 0.1));
+        const shuffled = filteredWords.slice().sort(() => Math.random() - 0.5);
+        const inputWords = shuffled.slice(0, inputCount);
+
+        // 2. 诊断KVM中的模因数量
+        let nonEmptyMemeCount = 0;
+        let totalWordCount = 0;
+
+        for (const [memeID, words] of system.kvm.memory.entries()) {
+            if (Array.isArray(words) && words.length > 0) {
+                nonEmptyMemeCount++;
+                totalWordCount += words.length;
+            }
+        }
+
+        if (nonEmptyMemeCount === 0) {
+            console.warn(`[RL-WARN] 系统KVM中无有效模因，无法评估! 总模因数: ${system.graph.getAllPoints().length}`);
+            return 0;
+        }
+
+        // 3. 计算每个模因和输入词的匹配度
+        const memeStats = [];
+        let foundMatch = false;
+
+        for (const meme of system.graph.getAllPoints()) {
+            // 确保所有KVM值为数组且标准化
+            let memeWords = system.kvm.get(meme.pointID);
+            if (!Array.isArray(memeWords)) {
+                memeWords = memeWords ? [String(memeWords)] : [];
+                system.kvm.set(meme.pointID, memeWords);
+            }
+
+            // 规范化词汇（确保小写+归一化）
+            const normalizedMemeWords = memeWords.map(word =>
+                typeof word === 'string' ? word.toLowerCase().trim() : String(word)
+            );
+
+            let overlap = 0;
+            for (const word of inputWords) {
+                if (normalizedMemeWords.includes(word)) {
+                    overlap++;
+                    foundMatch = true;
+                }
+            }
+
+            const coverage = normalizedMemeWords.length > 0 ? overlap / normalizedMemeWords.length : 0;
+            if (coverage > 0) {
+                memeStats.push({ meme, coverage });
+            }
+        }
+
+        // 4. 如果没找到匹配，记录调试信息
+        if (!foundMatch) {
+            console.log(`[RL-DEBUG] ${system.isClone ? '克隆' : '原'}系统没有匹配: 输入词=${inputWords.slice(0, 3).join(',')}`);
+
+            // 取样几个模因检查它们的词汇
+            const sampleMemes = system.graph.getAllPoints().slice(0, 3);
+            for (const meme of sampleMemes) {
+                const words = system.kvm.get(meme.pointID) || [];
+                console.log(`[RL-DEBUG] 模因${meme.pointID}词汇样本: ${words.slice(0, 5).join(',')}`);
+            }
+
+            return 0;
+        }
+
+        // 5. 基于匹配的模因进行多源信号扩散
+        const activated = memeStats.filter(m => m.coverage > 0);
+        const startIDs = activated.map(m => m.meme.pointID);
+        const strengths = activated.map(m => m.coverage);
+        const signalMap = system.propagateSignalMultiSource(startIDs, strengths, 0.5, 2);
+
+        // 6. 收集激活模因的词汇作为输出
+        let outputWords = [];
+        for (const memeID of Array.from(signalMap.keys())) {
+            const words = system.kvm.get(memeID) || [];
+            outputWords.push(...words);
+            if (outputWords.length >= uniqueWords.length) break;
+        }
+
+        outputWords = Array.from(new Set(outputWords));
+
+        // 7. 计算覆盖率
+        let covered = 0;
+        for (const word of uniqueWords) {
+            if (outputWords.includes(word)) covered++;
+        }
+
+        const coverageRatio = uniqueWords.length > 0 ? covered / uniqueWords.length : 0;
+        return coverageRatio;
+    }
+    // 学习过程
+    // ReinforcementLearner类内
+    // ReinforcementLearner类内
+    async learn(iterations = 5) {
+        console.log(`[RL] 开始自主学习，计划${iterations}轮迭代`);
+
+        // 用当前runtime作为每轮的基础
+        let currentRuntime = this.runtime;
+
+        for (let i = 0; i < iterations; i++) {
+            console.log(`\n[RL] 第${i + 1}/${iterations}轮学习开始...`);
+
+            // 1. 用当前系统识别模因边关系
+            const associationLayer = new AssociationLayer(currentRuntime);
+            const patterns = associationLayer.identifyPatterns();
+
+            // 2. 克隆系统
+            const systemClone = await associationLayer.cloneSystem();
+            // 这里要加上
+            associationLayer.patterns = associationLayer.identifyPatterns();
+            // 3. 应用模式到克隆系统
+            associationLayer.applyPatternsToClone(systemClone);
+
+            // 4. 评估原系统和克隆系统
+            const testArticles = this.loadTestArticles();
+            console.log(`[RL] 加载了${testArticles.length}篇测试文章`);
+
+            let origCoverages = [];
+            let cloneCoverages = [];
+
+            for (let j = 0; j < testArticles.length; j++) {
+                const article = testArticles[j];
+                const origCoverage = this.evaluateSystem(currentRuntime, article);
+                const cloneCoverage = this.evaluateSystem(systemClone, article);
+                origCoverages.push(origCoverage);
+                cloneCoverages.push(cloneCoverage);
+                console.log(`[RL] 文章#${j + 1}: 原系统覆盖率=${(origCoverage * 100).toFixed(1)}%, 克隆系统覆盖率=${(cloneCoverage * 100).toFixed(1)}%`);
+            }
+
+            // 计算总和减方差
+            const sum = arr => arr.reduce((a, b) => a + b, 0);
+            const mean = arr => arr.length ? sum(arr) / arr.length : 0;
+            const variance = arr => {
+                const m = mean(arr);
+                return arr.length ? arr.reduce((a, b) => a + (b - m) ** 2, 0) / arr.length : 0;
+            };
+            const origScore = sum(origCoverages) - Math.sqrt(variance(origCoverages));
+            const cloneScore = sum(cloneCoverages) - Math.sqrt(variance(cloneCoverages));
+
+            console.log(`[RL] 评估结果: 原系统指标=${origScore.toFixed(4)}, 克隆系统指标=${cloneScore.toFixed(4)}`);
+
+            // 5. 选择更好的系统
+            if (cloneScore > origScore) {
+                console.log(`[RL] 克隆系统表现更好! 替换原系统`);
+                this.replaceSystem(systemClone);
+                currentRuntime = systemClone;
+                // 修复：同步 controller 的 runtime
+                if (global.ctrl) global.ctrl.updateRuntime(systemClone);
+            } else {
+                console.log(`[RL] 原系统表现更好或相同，保留原系统`);
+                // 保持 currentRuntime 不变
+            }
+        }
+
+        console.log(`[RL] 自主学习完成`);
+    }
+
+    replaceSystem(newSystem) {
+        // 保存旧的 runtime 引用
+        const oldRuntime = this.runtime;
+
+        // 更新自己的 runtime
+        this.runtime = newSystem;
+
+        // 查找并更新对应的控制器
+        if (global.ctrlA && global.ctrlA.runtime === oldRuntime) {
+            console.log(`[RL] 更新控制器A的runtime`);
+            global.ctrlA.updateRuntime(newSystem);
+        }
+        if (global.ctrlB && global.ctrlB.runtime === oldRuntime) {
+            console.log(`[RL] 更新控制器B的runtime`);
+            global.ctrlB.updateRuntime(newSystem);
+        }
+        if (global.ctrlC && global.ctrlC.runtime === oldRuntime) {
+            console.log(`[RL] 更新控制器C的runtime`);
+            global.ctrlC.updateRuntime(newSystem);
+        }
+
+        // 同时更新全局 ctrl (如果存在)
+        if (global.ctrl && global.ctrl.runtime === oldRuntime) {
+            global.ctrl.updateRuntime(newSystem);
+        }
+    }
+}
+/**
+ * 模因阻断模块 - 识别并隔离恶性模因
+ * 恶性模因特征: 
+ * 1. 自行传播倾向
+ * 2. 不可被自我观察
+ */
+class memeBarrier {
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.suspiciousMemesHistory = new Map(); // 记录可疑模因历史
+        this.maliciousThreshold = 2.0; // 初始恶性阈值
+        this.learningRate = 0.05; // 学习率
+        this.scanInterval = null; // 保存定时器引用
+        this.metrics = {
+            totalScans: 0,
+            totalBlocked: 0,
+            falsePositives: 0,
+            falseNegatives: 0
+        };
+        // 特征权重：[传播率, 自指率, 连接异常率]
+        this.features = [0.5, 0.3, 0.2];
+
+        // 记录网络连接历史快照，用于对比检测异常增长
+        this.networkSnapshots = [];
+    }
+
+    // 启动模因阻断扫描
+    start() {
+        if (this.scanInterval) return;
+        this.scanInterval = setInterval(() => this.scanNetwork(), 1000 * 1000);
+        console.log('[BARRIER] 模因阻断系统已启动，每1000秒扫描一次');
+
+        // 创建初始网络快照
+        this.takeNetworkSnapshot();
+    }
+
+    // 停止扫描
+    stop() {
+        if (this.scanInterval) {
+            clearInterval(this.scanInterval);
+            this.scanInterval = null;
+            console.log('[BARRIER] 模因阻断系统已停止');
+        }
+    }
+
+    // 创建网络结构快照，用于后续分析
+    takeNetworkSnapshot() {
+        const memes = this.runtime.graph.getAllPoints();
+        const snapshot = {
+            timestamp: Date.now(),
+            memeStats: memes.map(meme => ({
+                memeID: meme.pointID,
+                connections: meme.connect.length,
+                words: (this.runtime.kvm.get(meme.pointID) || []).length,
+                outDegree: meme.connect.filter(([_, __, dir]) => dir === 2).length,
+                inDegree: meme.connect.filter(([_, __, dir]) => dir === 1).length,
+                biDegree: meme.connect.filter(([_, __, dir]) => dir === 0).length
+            }))
+        };
+
+        this.networkSnapshots.push(snapshot);
+
+        // 只保留最近5个快照
+        if (this.networkSnapshots.length > 5) {
+            this.networkSnapshots.shift();
+        }
+    }
+
+    // 扫描整个网络
+    scanNetwork() {
+        console.log('[BARRIER] 开始扫描模因网络...');
+        this.metrics.totalScans++;
+
+        this.takeNetworkSnapshot();
+
+        if (this.networkSnapshots.length < 2) {
+            console.log('[BARRIER] 快照数据不足，等待下次扫描');
+            return;
+        }
+
+        const memes = this.runtime.graph.getAllPoints();
+        let maxScore = -Infinity;
+        let topSuspicious = [];
+
+        for (const meme of memes) {
+            const maliciousScore = this.evaluateMaliciousness(meme);
+            if (maliciousScore > maxScore) {
+                maxScore = maliciousScore;
+                topSuspicious = [{ memeID: meme.pointID, score: maliciousScore, reason: this.generateReason(meme, maliciousScore) }];
+            } else if (maliciousScore === maxScore) {
+                topSuspicious.push({ memeID: meme.pointID, score: maliciousScore, reason: this.generateReason(meme, maliciousScore) });
+            }
+        }
+
+        // 只隔离评分最高的（可并列）
+        if (maxScore >= this.maliciousThreshold) {
+            for (const { memeID, score, reason } of topSuspicious) {
+                this.isolateMeme(memeID, score, reason);
+                this.metrics.totalBlocked++;
+            }
+            console.log(`[BARRIER] 本轮隔离${topSuspicious.length}个评分最高的模因`);
+        } else {
+            console.log(`[BARRIER] 本轮无可疑模因达到阈值`);
+        }
+
+        if (this.metrics.totalScans % 3 === 0) {
+            this.updateEvaluationFunction();
+        }
+    }
+    // 生成可疑原因描述
+    generateReason(meme, score) {
+        const reasons = [];
+
+        // 计算各个指标
+        const outgoingConnections = meme.connect.length;
+        const avgConnections = this.getAverageConnections();
+        const propagationRate = outgoingConnections / (avgConnections || 1);
+
+        const selfReferences = meme.connect.filter(([_, pointID]) => pointID === meme.pointID).length;
+        const selfReferenceRate = 1 - (selfReferences / (outgoingConnections || 1));
+
+        const connectionAbnormality = this.detectConnectionAbnormality(meme);
+
+        // 分析增长率
+        const growthRate = this.calculateGrowthRate(meme.pointID);
+
+        // 根据各指标贡献确定原因
+        if (propagationRate > 1.5) reasons.push(`传播率过高(${propagationRate.toFixed(2)})`);
+        if (selfReferenceRate > 0.9) reasons.push(`自指率过低(${selfReferenceRate.toFixed(2)})`);
+        if (connectionAbnormality > 0.7) reasons.push(`连接模式异常(${connectionAbnormality.toFixed(2)})`);
+        if (growthRate > 1.5) reasons.push(`连接增长过快(${growthRate.toFixed(2)}x)`);
+
+        return reasons.join(', ');
+    }
+
+    evaluateMaliciousness(meme) {
+        // 1. 计算传播率
+        const outgoingConnections = meme.connect.length;
+        const avgConnections = this.getAverageConnections();
+        const propagationRate = outgoingConnections / (avgConnections || 1);
+
+        // 2. 计算自指率 - 恶性模因自指率高
+        const selfReferences = meme.connect.filter(([_, pointID]) => pointID === meme.pointID).length;
+        const selfReferenceRate = (selfReferences / (outgoingConnections || 1)); // ← 只改这一行
+
+        // 3. 连接异常率
+        const connectionAbnormality = this.detectConnectionAbnormality(meme);
+
+        // 4. 增长率
+        const growthRate = this.calculateGrowthRate(meme.pointID);
+        const growthFactor = Math.min(1, (growthRate - 1) / 2);
+
+        // 综合评分
+        return this.features[0] * propagationRate +
+            this.features[1] * selfReferenceRate + // ← 只改这里
+            this.features[2] * connectionAbnormality +
+            0.3 * growthFactor;
+    }
+
+    // 计算模因的增长率
+    calculateGrowthRate(memeID) {
+        if (this.networkSnapshots.length < 2) return 1.0;
+
+        const current = this.networkSnapshots[this.networkSnapshots.length - 1];
+        const previous = this.networkSnapshots[this.networkSnapshots.length - 2];
+
+        const currentStats = current.memeStats.find(m => m.memeID === memeID);
+        const previousStats = previous.memeStats.find(m => m.memeID === memeID);
+
+        if (!currentStats || !previousStats) return 1.0;
+
+        // 计算连接数增长率
+        return previousStats.connections > 0 ?
+            currentStats.connections / previousStats.connections :
+            (currentStats.connections > 0 ? 2.0 : 1.0);
+    }
+
+    // 计算平均连接数
+    getAverageConnections() {
+        const memes = this.runtime.graph.getAllPoints();
+        if (memes.length === 0) return 0;
+
+        const totalConnections = memes.reduce((sum, meme) => sum + meme.connect.length, 0);
+        return totalConnections / memes.length;
+    }
+
+    // 检测连接异常
+    detectConnectionAbnormality(meme) {
+        // 分析连接模式是否异常
+        const connections = meme.connect;
+        if (connections.length === 0) return 0;
+
+        // 1. 检查权重分布
+        const weights = connections.map(([weight]) => weight);
+        const avgWeight = weights.reduce((sum, w) => sum + w, 0) / weights.length;
+        const stdDev = Math.sqrt(
+            weights.reduce((sum, w) => sum + Math.pow(w - avgWeight, 2), 0) / weights.length
+        );
+
+        // 权重分布异常性
+        const weightAbnormality = stdDev / (avgWeight || 1);
+
+        // 2. 检查方向分布 - 恶性模因倾向于单向输出
+        const directionCounts = {
+            bidirectional: connections.filter(([_, __, dir]) => dir === 0).length,
+            inward: connections.filter(([_, __, dir]) => dir === 1).length,
+            outward: connections.filter(([_, __, dir]) => dir === 2).length
+        };
+
+        // 如果几乎都是向外的连接，这是可疑的
+        const directionBalance = directionCounts.outward /
+            (directionCounts.bidirectional + directionCounts.inward + 1);
+
+        // 3. 检查邻居多样性
+        const uniqueNeighbors = new Set(connections.map(([_, pointID]) => pointID)).size;
+        const neighborDiversity = uniqueNeighbors / connections.length;
+
+        return (weightAbnormality * 0.3 + directionBalance * 0.5 + neighborDiversity * 0.2);
+    }
+
+    // 隔离可疑模因
+    isolateMeme(memeID, maliciousScore, reason) {
+        console.log(`[BARRIER] 隔离可疑模因: ${memeID}, 恶性评分: ${maliciousScore.toFixed(4)}`);
+        console.log(`[BARRIER] 原因: ${reason}`);
+
+        // 记录历史
+        if (!this.suspiciousMemesHistory.has(memeID)) {
+            this.suspiciousMemesHistory.set(memeID, []);
+        }
+
+        const meme = this.runtime.graph.points.get(memeID);
+        if (!meme) return;
+
+        const connectionCount = meme.connect.length;
+        this.suspiciousMemesHistory.get(memeID).push({
+            timestamp: Date.now(),
+            score: maliciousScore,
+            reason,
+            connectionCount
+        });
+
+        // 增加该模因与其他节点的距离
+        for (const [index, [weight, neighborID, direction]] of meme.connect.entries()) {
+            // 增加边权重 (增加距离)
+            const increaseFactor = 1 + maliciousScore;
+            const newWeight = Math.min(10, weight * increaseFactor); // 限制最大权重
+
+            // 更新边权重
+            meme.connect[index][0] = newWeight;
+
+            // 如果是双向连接，同时增加另一端的权重
+            if (direction === 0) {
+                const neighbor = this.runtime.graph.points.get(neighborID);
+                if (neighbor) {
+                    const reverseEdgeIndex = neighbor.connect.findIndex(
+                        ([_, id, dir]) => id === memeID && dir === 0
+                    );
+                    if (reverseEdgeIndex !== -1) {
+                        neighbor.connect[reverseEdgeIndex][0] = newWeight;
+                    }
+                }
+            }
+        }
+
+        // 极端情况：如果评分非常高，考虑完全隔离
+        if (maliciousScore > 0.9) {
+            console.log(`[BARRIER] 模因 ${memeID} 评分极高，标记为恶性`);
+            // 标记为恶性模因
+            JSON.stringify({
+                timestamp: Date.now(),
+                score: maliciousScore,
+                reason
+            });
+        }
+    }
+
+    // 强化学习更新评估函数
+    updateEvaluationFunction() {
+        console.log('[BARRIER] 更新恶性模因评估函数...');
+
+        // 1. 分析历史数据，找出可能的错误判断
+        let falsePositives = 0;
+        let falseNegatives = 0;
+
+        // 分析可能的误判
+        for (const [memeID, history] of this.suspiciousMemesHistory.entries()) {
+            // 至少需要2条历史记录才能分析
+            if (history.length < 2) continue;
+
+            // 检查隔离后的行为变化
+            const behaviorChange = this.analyzeMemeEvolution(memeID, history);
+
+            // 如果模因在隔离后仍然增长，可能是误判
+            if (behaviorChange > 0.2) {
+                falsePositives++;
+            }
+        }
+
+        // 寻找漏判的恶性模因
+        const missedMalicious = this.detectMissedMaliciousMemes();
+        falseNegatives = missedMalicious.length;
+
+        // 2. 根据错误类型调整阈值和特征权重
+        if (falsePositives > falseNegatives * 2) {
+            // 太多误判，提高阈值，减少灵敏度
+            this.maliciousThreshold = Math.min(0.95, this.maliciousThreshold + this.learningRate);
+            // 调整特征权重
+            this.features[2] = Math.max(0.1, this.features[2] - this.learningRate); // 减少连接异常权重
+            this.features[0] = Math.min(0.7, this.features[0] + this.learningRate); // 增加传播率权重
+        } else if (falseNegatives > falsePositives * 2) {
+            // 太多漏判，降低阈值，提高灵敏度
+            this.maliciousThreshold = Math.max(0.5, this.maliciousThreshold - this.learningRate);
+            // 调整特征权重
+            this.features[0] = Math.max(0.2, this.features[0] - this.learningRate); // 减少传播率权重
+            this.features[2] = Math.min(0.6, this.features[2] + this.learningRate); // 增加连接异常权重
+        }
+
+        // 归一化特征权重
+        const sum = this.features.reduce((a, b) => a + b, 0);
+        this.features = this.features.map(f => f / sum);
+
+        // 更新指标
+        this.metrics.falsePositives += falsePositives;
+        this.metrics.falseNegatives += falseNegatives;
+
+        console.log(`[BARRIER] 评估函数已更新: 阈值=${this.maliciousThreshold.toFixed(3)}, 权重=[${this.features.map(f => f.toFixed(2)).join(', ')}]`);
+        console.log(`[BARRIER] 本轮检测到: 误判=${falsePositives}, 漏判=${falseNegatives}`);
+    }
+
+    // 分析模因的演化
+    analyzeMemeEvolution(memeID, history) {
+        const meme = this.runtime.graph.points.get(memeID);
+        if (!meme) return 0;
+
+        // 获取第一次和最后一次隔离记录
+        const firstRecord = history[0];
+        const lastRecord = history[history.length - 1];
+
+        // 计算连接数变化
+        const initialConnections = firstRecord.connectionCount || 0;
+        const currentConnections = meme.connect.length;
+
+        // 计算隔离后的相对增长率
+        // 如果是真正的恶性模因，隔离应该有效阻止其增长
+        const timeDiff = (lastRecord.timestamp - firstRecord.timestamp) / (1000 * 60 * 60 * 24); // 天数
+        const growthRate = (currentConnections - initialConnections) / (initialConnections || 1);
+        const normalizedGrowth = growthRate / (timeDiff || 1); // 归一化为每天增长率
+
+        return normalizedGrowth;
+    }
+
+    // 检测可能漏判的恶性模因
+    detectMissedMaliciousMemes() {
+        if (this.networkSnapshots.length < 2) return [];
+
+        const currentSnapshot = this.networkSnapshots[this.networkSnapshots.length - 1];
+        const previousSnapshot = this.networkSnapshots[this.networkSnapshots.length - 2];
+
+        const missedMalicious = [];
+
+        // 检查所有模因的异常增长
+        for (const currentStat of currentSnapshot.memeStats) {
+            // 跳过已识别的可疑模因
+            if (this.suspiciousMemesHistory.has(currentStat.memeID)) continue;
+
+            const previousStat = previousSnapshot.memeStats.find(
+                m => m.memeID === currentStat.memeID
+            );
+
+            if (!previousStat) continue; // 新模因，无法比较
+
+            // 检查连接数异常增长
+            const connectionGrowth = previousStat.connections > 0 ?
+                currentStat.connections / previousStat.connections :
+                (currentStat.connections > 0 ? 2.0 : 1.0);
+
+            // 检查单向外连接比例异常
+            const outwardRatio = currentStat.outDegree /
+                (currentStat.connections || 1);
+
+            // 如果增长率异常高且主要是向外的连接
+            if (connectionGrowth > 2.0 && outwardRatio > 0.7) {
+                missedMalicious.push({
+                    memeID: currentStat.memeID,
+                    growthRate: connectionGrowth,
+                    outwardRatio
+                });
+            }
+        }
+
+        return missedMalicious;
+    }
+
+    // 获取统计数据
+    getStats() {
+        return {
+            ...this.metrics,
+            threshold: this.maliciousThreshold,
+            features: this.features,
+            suspiciousCount: this.suspiciousMemesHistory.size
+        };
+    }
+}
+
+class controller {
+    constructor() {
+        this.runtime = new Runtime();
+        // 启动时自动用Spider构建词表
+        this.articles = this.runtime.buildVocabFromSpider();
+        this.isLearning = false;
+        this.isMainLoopRunning = false;
+
+        // 初始化快照管理器 (仅为ctrlA实例初始化)
+        if (this === global.ctrlA || !global.ctrlA) {
+            this.snapshotManager = new SnapshotManager(this.runtime);
+        }
+    }
+    updateRuntime(newRuntime) {
+        if (this.runtime) this.runtime.cleanup();
+        this.runtime = newRuntime;
+    }
+    // 处理用户输入
+    async handleInput(text) {
+        const words = text.toLowerCase().split(' ').filter(w => w.length > 0);
+        this.runtime.processInput(words, { addNewWords: false });
+        // 用模因网络参与推理
+        //console.log('[DEBUG] 当前所有模因节点:', this.runtime.kvm.memory);
+        return await this.runtime.generateResponseWithMemes(words);
+    }
+    // 启动自主学习
+    async startSelfLearning(iterations) {
+        if (iterations === undefined) {
+            iterations = this.config.learningIterations !== undefined ? this.config.learningIterations : 5;
+        }
+        if (this.isLearning) return;
+        this.isLearning = true;
+        await this.runtime.startSelfLearning(iterations);
+        this.isLearning = false;
+    }
+    // 在controller类内
+    startMainLoop() {
+        if (this.isMainLoopRunning) return;
+        this.isMainLoopRunning = true;
+        this.runtime.runMainLoop().then(() => {
+            this.isMainLoopRunning = false;
+        });
+    }
+    // 添加快照相关方法
+    async createSnapshot(name) {
+        if (!this.snapshotManager) {
+            console.error('[SNAPSHOT] 当前控制器未初始化快照管理器');
+            return null;
+        }
+
+        if (this.isLearning || this.isMainLoopRunning) {
+            console.warn('[SNAPSHOT] 系统忙碌，无法创建快照');
+            return null;
+        }
+
+        return await this.snapshotManager.createSnapshot(name || 'manual');
+    }
+
+    async restoreFromSnapshot(snapshotId) {
+        if (!this.snapshotManager) {
+            console.error('[SNAPSHOT] 当前控制器未初始化快照管理器');
+            return false;
+        }
+
+        if (this.isLearning || this.isMainLoopRunning) {
+            console.warn('[SNAPSHOT] 系统忙碌，无法恢复快照');
+            return false;
+        }
+
+        return await this.snapshotManager.restoreSnapshot(snapshotId);
+    }
+
+    getSnapshotList() {
+        if (!this.snapshotManager) {
+            console.error('[SNAPSHOT] 当前控制器未初始化快照管理器');
+            return [];
+        }
+
+        return this.snapshotManager.getSnapshotList();
+    }
+
+    deleteSnapshot(snapshotId) {
+        if (!this.snapshotManager) {
+            console.error('[SNAPSHOT] 当前控制器未初始化快照管理器');
+            return false;
+        }
+
+        return this.snapshotManager.deleteSnapshot(snapshotId);
+    }
+}
+let latestRuntimeData = null;
+let saveQueued = false;
+
+
+// 保存所有点、图、词表等到硬盘
+function saveAll(runtime) {
+    // 只更新内存缓存
+    latestRuntimeData = {
+        memes: runtime.graph.getAllPoints(),
+        wordGraph: Array.from(runtime.wordGraph.points.values()),
+        kvm: Array.from(runtime.kvm.memory.entries()),
+        vocab: runtime.vocabManager.vocab,
+        wordAccessLog: Array.from(runtime.wordAccessLog ? runtime.wordAccessLog.entries() : [])
+    };
+    // 标记有保存请求
+    saveQueued = true;
+}
+// 定时真正写入硬盘，只保存最新的
+setInterval(() => {
+    if (saveQueued && latestRuntimeData) {
+        fs.writeFile(SAVE_PATH, JSON.stringify(latestRuntimeData, null, 2), 'utf-8', () => {
+            console.log(`[SAVE] 系统状态已保存到 ${SAVE_PATH}`);
+        });
+        saveQueued = false;
+    }
+}, 10000); // 每10秒最多写盘一次
+// 从硬盘恢复
+function loadAll(runtime) {
+    if (!fs.existsSync(SAVE_PATH)) return;
+    const data = JSON.parse(fs.readFileSync(SAVE_PATH, 'utf-8'));
+    if (data.memes) runtime.loadGraph(data.memes);
+    if (data.wordGraph) {
+        for (const point of data.wordGraph) {
+            runtime.wordGraph.addPoint(point.pointID, point.connect);
+        }
+    }
+    // 3. 修改 loadAll 中的数据恢复
+    if (data.kvm) {
+        for (const [k, v] of data.kvm) {
+            runtime.kvm.set(k, Array.isArray(v) ? v : [String(v)]);
+            // 确保一定是数组
+        }
+    }
+    if (data.vocab) {
+        runtime.vocabManager.vocab = data.vocab;
+        runtime.vocabManager.updateMappings();
+    }
+    if (data.wordAccessLog && runtime.wordAccessLog) {
+        runtime.wordAccessLog = new Map(data.wordAccessLog);
+    }
+    console.log(`[LOAD] 系统状态已从 ${SAVE_PATH} 恢复`);
+}
+
+
+
+function scheduleCrossLearning() {
+    const cycle = 1800 * 1000;      // 每轮周期（毫秒）
+    const learnTime = 200 * 1000;   // 每轮学习后等待时间
+
+    // A -> B
+    registerInterval(() => {
+        if (global.ctrlA.isLearning || global.ctrlB.isLearning || global.ctrlC.isLearning || isShuttingDown) return;
+        console.log('[CROSS] A开始学习');
+        global.ctrlA.startSelfLearning(3).then(() => {
+            setTimeout(async () => {
+                console.log('[CROSS] A将成果传递给B');
+                const associationLayer = new AssociationLayer(global.ctrlA.runtime);
+
+                // 归一化一致性测试
+                const testWord = "testing";
+                const normalizedWord = global.ctrlA.runtime.spider.lemmatize(testWord);
+                console.log(`[CROSS-CHECK] 词归一化测试: "${testWord}" -> "${normalizedWord}"`);
+                //const associationLayer = new AssociationLayer(global.ctrlA.runtime);
+                // 这里要加上
+                associationLayer.patterns = associationLayer.identifyPatterns();
+                // 克隆
+                const systemClone = await associationLayer.cloneSystem();
+                systemClone.spider = global.ctrlA.runtime.spider;
+                associationLayer.applyPatternsToClone(systemClone);
+
+                verifySystemConsistency(global.ctrlA.runtime, systemClone);
+
+                // 预热克隆系统
+                console.log('[CROSS] 预热克隆系统...');
+                const sampleWords = Array.from(
+                    new Set([...systemClone.vocabManager.vocab].slice(4, 20))
+                ).filter(w => w.length > 1);
+                await systemClone.processInput(sampleWords, { addNewWords: false });
+
+                await systemClone.startSelfLearning(3);
+                global.ctrlB.updateRuntime(systemClone);
+
+                verifySystemConsistency(global.ctrlA.runtime, global.ctrlB.runtime);
+
+                console.log('[CROSS] 已将A的系统更新到B');
+                testCloneMatching(global.ctrlB.runtime);
+            }, learnTime);
+        });
+    }, cycle);
+
+    // B -> C
+    registerInterval(() => {
+        if (global.ctrlA.isLearning || global.ctrlB.isLearning || global.ctrlC.isLearning || isShuttingDown) return;
+        global.ctrlB.startSelfLearning(3).then(() => {
+            setTimeout(async () => {
+                console.log('[CROSS] B将成果传递给C');
+                const associationLayer = new AssociationLayer(global.ctrlB.runtime);
+
+                const testWord = "testing";
+                const normalizedWord = global.ctrlB.runtime.spider.lemmatize(testWord);
+                console.log(`[CROSS-CHECK] 词归一化测试: "${testWord}" -> "${normalizedWord}"`);
+                // 这里要加上
+                associationLayer.patterns = associationLayer.identifyPatterns();
+                const systemClone = await associationLayer.cloneSystem();
+                systemClone.spider = global.ctrlB.runtime.spider;
+                associationLayer.applyPatternsToClone(systemClone);
+
+                verifySystemConsistency(global.ctrlB.runtime, systemClone);
+
+                console.log('[CROSS] 预热克隆系统...');
+                const sampleWords = Array.from(
+                    new Set([...systemClone.vocabManager.vocab].slice(4, 20))
+                ).filter(w => w.length > 1);
+                await systemClone.processInput(sampleWords, { addNewWords: false });
+
+                await systemClone.startSelfLearning(3);
+                global.ctrlC.updateRuntime(systemClone);
+
+                verifySystemConsistency(global.ctrlB.runtime, global.ctrlC.runtime);
+
+                console.log('[CROSS] 已将B的系统更新到C');
+                testCloneMatching(global.ctrlC.runtime);
+            }, learnTime);
+        });
+    }, cycle);
+
+    // C -> A
+    registerInterval(() => {
+        if (global.ctrlA.isLearning || global.ctrlB.isLearning || global.ctrlC.isLearning || isShuttingDown) return;
+        global.ctrlC.startSelfLearning(3).then(() => {
+            setTimeout(async () => {
+                console.log('[CROSS] C将成果传递给A');
+                const associationLayer = new AssociationLayer(global.ctrlC.runtime);
+
+                const testWord = "testing";
+                const normalizedWord = global.ctrlC.runtime.spider.lemmatize(testWord);
+                console.log(`[CROSS-CHECK] 词归一化测试: "${testWord}" -> "${normalizedWord}"`);
+                // 这里要加上
+                associationLayer.patterns = associationLayer.identifyPatterns();
+                const systemClone = await associationLayer.cloneSystem();
+                systemClone.spider = global.ctrlC.runtime.spider;
+                associationLayer.applyPatternsToClone(systemClone);
+
+                verifySystemConsistency(global.ctrlC.runtime, systemClone);
+
+                console.log('[CROSS] 预热克隆系统...');
+                const sampleWords = Array.from(
+                    new Set([...systemClone.vocabManager.vocab].slice(4, 20))
+                ).filter(w => w.length > 1);
+                await systemClone.processInput(sampleWords, { addNewWords: false });
+
+                await systemClone.startSelfLearning(3);
+                global.ctrlA.updateRuntime(systemClone);
+
+                verifySystemConsistency(global.ctrlC.runtime, global.ctrlA.runtime);
+
+                console.log('[CROSS] 已将C的系统更新到A');
+                testCloneMatching(global.ctrlA.runtime);
+            }, learnTime);
+        });
+        console.log('Publishing runtime state to Redis...');
+        if (!RuntimeMessage) return; // protobuf未加载完成
+        if (!redisClient || !redisClient.isOpen) {
+            console.warn('[REDIS] 客户端未连接，跳过发布');
+            return;
+        }
+        if (!RuntimeMessage) return;
+        if (global.ctrlA.runtime.isLearning || global.ctrlA.runtime.isMainLoopRunning) return;
+        const plainObj = runtimeToPlain(global.ctrlA.runtime);
+        const errMsg = RuntimeMessage.verify(plainObj);
+        if (errMsg) throw Error(errMsg);
+        const message = RuntimeMessage.create(plainObj);
+        const buffer = RuntimeMessage.encode(message).finish();
+        redisClient.publish(`AI-model-${__dirname}`, buffer);
+        console.log('已发布运行时状态到Redis');
+    }, cycle);
+}
+
+// 新增：测试克隆系统的词汇匹配能力
+function testCloneMatching(runtime) {
+    // 从词表中随机选取10个词
+    const sampleSize = Math.min(10, runtime.vocabManager.vocab.length - 4);
+    const sampleWords = runtime.vocabManager.vocab
+        .slice(4, 4 + sampleSize) // 跳过前4个特殊词
+        .filter(w => w && w.length > 2);
+
+    if (sampleWords.length === 0) {
+        console.log('[CROSS-TEST] 没有足够的词汇进行测试');
+        return;
+    }
+
+    console.log(`[CROSS-TEST] 使用${sampleWords.length}个词测试匹配能力: ${sampleWords.slice(0, 3).join(',')}`);
+
+    // 检查这些词是否能匹配模因
+    let matchFound = false;
+    let checkedMemes = 0;
+
+    for (const meme of runtime.graph.getAllPoints()) {
+        if (checkedMemes > 100) break; // 限制检查数量
+
+        const memeWords = runtime.kvm.get(meme.pointID) || [];
+        for (const testWord of sampleWords) {
+            if (memeWords.includes(testWord)) {
+                console.log(`[CROSS-TEST] 匹配成功! 词"${testWord}"在模因${meme.pointID}中`);
+                matchFound = true;
+                break;
+            }
+        }
+
+        if (matchFound) break;
+        checkedMemes++;
+    }
+
+    if (!matchFound) {
+        console.log('[CROSS-TEST] 警告: 无法找到任何词汇匹配!');
+
+        // 检查词表和KVM中的词汇格式
+        const sampleKVM = Array.from(runtime.kvm.memory.entries()).slice(0, 3);
+        for (const [memeID, words] of sampleKVM) {
+            console.log(`[CROSS-TEST] 模因${memeID}词汇样本: ${Array.isArray(words) ? words.slice(0, 5).join(',') : '非数组'}`);
+        }
+    }
+}
+
+function runtimeToPlain(runtime) {
+    return {
+        memes: runtime.graph.getAllPoints().map(meme => ({
+            pointID: meme.pointID,
+            connect: meme.connect.map(([weight, pointID, direction]) => ({
+                weight,
+                pointID,
+                direction
+            }))
+        })),
+        wordGraph: Array.from(runtime.wordGraph.points.values()).map(point => ({
+            pointID: point.pointID,
+            connect: point.connect.map(([weight, pointID, direction]) => ({
+                weight,
+                pointID,
+                direction
+            }))
+        })),
+        kvm: Array.from(runtime.kvm.memory.entries()).map(([key, value]) => ({
+            key,
+            value: Array.isArray(value) ? value : (value == null ? [] : [value]) // 保证为数组
+        })),
+        vocab: runtime.vocabManager.vocab
+    };
+}
+function safePoolExec(method, args, fallback) {
+    if (isShuttingDown) return Promise.resolve(fallback);
+    try {
+        return pool.exec(method, args);
+    } catch (e) {
+        if (String(e && e.message).toLowerCase().includes('terminated')) {
+            return Promise.resolve(fallback);
+        }
+        throw e;
+    }
+}
+function setupExitHandler() {
+    let exitingOnce = false;
+    let isExiting = false;
+
+    const exitHandler = async () => {
+        if (isExiting) return; // 防止重复执行
+        isExiting = true;
+        if (exitingOnce) {
+            return;
+        }
+        exitingOnce = true;
+        isShuttingDown = true;
+        console.log('正在保存数据并关闭系统...');
+        try {
+            // 尝试创建退出快照
+            if (global.ctrlA && global.ctrlA.snapshotManager) {
+                console.log('[EXIT] 创建退出快照...');
+                await global.ctrlA.snapshotManager.createSnapshot('exit_snapshot');
+            }
+
+            // 原有保存逻辑
+            if (global.ctrlA && global.ctrlA.runtime) saveAll(global.ctrlA.runtime);
+            //if (global.ctrlB && global.ctrlB.runtime) saveAll(global.ctrlB.runtime);
+            //if (global.ctrlC && global.ctrlC.runtime) saveAll(global.ctrlC.runtime);
+            for (const t of crossTimers) { try { clearInterval(t); } catch (_) { } }
+            // ...existing code...
+            if (pool) {
+                try { await pool.terminate(true); } catch (err) { console.error('关闭工作池时出错:', err.message); }
+            }
+        } catch (err) {
+            console.error('关闭过程中出错:', err);
+        }
+        // 给异步操作一点时间完成
+        setTimeout(() => process.exit(0), 2000);
+    };
+
+    process.on('SIGINT', exitHandler);
+    process.on('SIGTERM', exitHandler);
+    process.on('uncaughtException', (err) => {
+        console.error('未捕获的异常:', err);
+        exitHandler();
+    });
+}
+// 添加定期垃圾回收帮助函数
+function optimizeMemory() {
+    const memUsage = process.memoryUsage();
+    console.log(`Memory usage before cleanup: RSS=${Math.round(memUsage.rss / 1024 / 1024)}MB, Heap=${Math.round(memUsage.heapUsed / 1024 / 1024)}MB/${Math.round(memUsage.heapTotal / 1024 / 1024)}MB`);
+
+    // 如果支持手动GC，则触发
+    if (global.gc) {
+        global.gc();
+        const afterUsage = process.memoryUsage();
+        console.log(`Memory usage after cleanup: RSS=${Math.round(afterUsage.rss / 1024 / 1024)}MB, Heap=${Math.round(afterUsage.heapUsed / 1024 / 1024)}MB/${Math.round(afterUsage.heapTotal / 1024 / 1024)}MB`);
+    }
+}
+async function main() {
+      console.log('Starting AI system...');
+    redisClient = redis.createClient();
+    // 创建三个全局控制器副本
+    const ctrlA = new controller();
+    const ctrlB = new controller();
+    const ctrlC = new controller();
+    global.ctrlA = ctrlA;
+    global.ctrlB = ctrlB;
+    global.ctrlC = ctrlC;
+    global.ctrl = ctrlA;
+
+    // 恢复各自持久化数据
+    loadAll(ctrlA.runtime);
+    loadAll(ctrlB.runtime);
+    loadAll(ctrlC.runtime);
+
+    // 用A副本初始化语料和模因
+    console.time('articleProcessing');
+    const articles = ctrlA.runtime.buildVocabFromSpider();
+    console.log(`Spider: 加载文章数: ${articles.length}`);
+
+    // 修复：在首次使用前定义 lemmaCsvPath
+    const BATCH_SIZE = 20;
+    const lemmaCsvPath = path.join(__dirname, 'lemma.csv');
+
+    for (let i = 0; i < articles.length; i += BATCH_SIZE) {
+        const batch = articles.slice(i, i + BATCH_SIZE);
+        // 修复：allSentences 作用域在循环内声明并初始化
+        let allSentences = [];
+        for (const article of batch) {
+            let sentences = article.split(/[.!?]+/);
+            const MAX_SENTENCE_WORDS = 40;
+            for (const sentence of sentences) {
+                const cleaned = sentence.toLowerCase().replace(/[^a-z\s]/g, ' ');
+                const words = cleaned.split(/\s+/).filter(w => w.length > 0);
+                if (words.length === 0) continue;
+                if (words.length > MAX_SENTENCE_WORDS) {
+                    for (let j = 0; j < words.length; j += MAX_SENTENCE_WORDS) {
+                        allSentences.push(words.slice(j, j + MAX_SENTENCE_WORDS));
+                    }
+                } else {
+                    allSentences.push(words);
+                }
+            }
+        }
+        // 修复：统一用 safePoolExec，避免 pool 终止时抛错
+        const normalizedBatch = await safePoolExec('batchLemmatize', [allSentences, lemmaCsvPath], []);
+        for (const normWords of normalizedBatch) {
+            if (normWords.length > 0) {
+                ctrlA.runtime.processInput(normWords);
+            }
+        }
+        await new Promise(resolve => setImmediate(resolve));
+        if (i % (BATCH_SIZE * 5) === 0) {
+            console.log(`[PROGRESS] 已处理 ${i}/${articles.length} 篇文章`);
+        }
+    }
+    console.timeEnd('articleProcessing');
+    optimizeMemory();
+    // 测试输入
+    console.log('\n=== Testing AI System ===');
+    await ctrlA.handleInput('I like apple');
+    await ctrlA.handleInput('I love orange');
+    await ctrlA.handleInput('you are good');
+    setInterval(async () => {
+        // 启动主循环（只用A副本）
+        ctrlA.startMainLoop();
+    }, 1000 * 60 * 7); // 每7分钟运行一次主循环
+    setInterval(async () => {
+        //每12分钟尝试启动memebarrier
+        ctrlA.runtime.memeBarrier.start();
+    }, 1000 * 60 * 12);
+    // API路由 - 只做学习，不返回结果
+    app.post('/api/chat', async (req, res) => {
+        try {
+            const { message } = req.body;
+            ctrlA.runtime.processInput(message.toLowerCase().split(' ').filter(w => w.length > 0));
+            ctrlA.runtime.updateAttentionLinks();
+            res.status(204).end(); // 不返回内容
+        } catch (error) {
+            res.status(500).json({ error: error.message });
+            console.error('Error in /api/chat:', error);
+        }
+    });
+
+    app.get('/api/status', (req, res) => {
+        res.json({ status: 'running', timestamp: new Date().toISOString() });
+    });
+    // API路由 - 快照管理
+    app.post('/api/snapshot/create', async (req, res) => {
+        try {
+            const { name } = req.body || {};
+            const snapshot = await ctrlA.createSnapshot(name || 'manual');
+            if (snapshot) {
+                res.json({ success: true, snapshot });
+            } else {
+                res.status(400).json({ success: false, error: '无法创建快照，系统可能正忙' });
+            }
+        } catch (error) {
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+
+    app.get('/api/snapshot/list', (req, res) => {
+        try {
+            const snapshots = ctrlA.getSnapshotList();
+            res.json({ success: true, snapshots });
+        } catch (error) {
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+
+    app.post('/api/snapshot/restore/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const success = await ctrlA.restoreFromSnapshot(id);
+            if (success) {
+                res.json({ success: true, message: '快照恢复成功' });
+            } else {
+                res.status(400).json({ success: false, error: '快照恢复失败，系统可能正忙或快照不存在' });
+            }
+        } catch (error) {
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+
+    app.delete('/api/snapshot/:id', (req, res) => {
+        try {
+            const { id } = req.params;
+            const success = ctrlA.deleteSnapshot(id);
+            if (success) {
+                res.json({ success: true, message: '快照删除成功' });
+            } else {
+                res.status(400).json({ success: false, error: '快照删除失败，快照可能不存在' });
+            }
+        } catch (error) {
+            res.status(500).json({ success: false, error: error.message });
+        }
+    });
+
+
+    // 模型默认参数
+    const modelDefaults = {
+        decayFactor: 0.5,
+        maxMemeWords: 100,
+        minOverlapThreshold: 2,
+        maliciousThreshold: 0.7,
+        learningIterations: 3,
+        iteration: 5,           // 新增
+        threshold: 3,           // 新增
+        decay: 1,               // 新增
+        decayK: 1,              // 新增
+        maxLen: 16,             // 新增
+        edgeWeight: 1           // 新增，GraphDB默认边权重
+    };
+    const currentModelParams = { ...modelDefaults };
+
+    app.get('/api/model/params', (req, res) => {
+        res.json({ current: currentModelParams, defaults: modelDefaults });
+    });
+
+    app.post('/api/model/params', (req, res) => {
+        try {
+            const updates = req.body;
+            // 参数校验（可根据需要扩展）
+            Object.assign(currentModelParams, updates);
+            applyModelParams(global.ctrlA?.runtime);
+            applyModelParams(global.ctrlB?.runtime);
+            applyModelParams(global.ctrlC?.runtime);
+            res.json({ success: true, params: currentModelParams });
+        } catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+
+    app.post('/api/model/params/reset', (req, res) => {
+        try {
+            Object.assign(currentModelParams, modelDefaults);
+            applyModelParams(global.ctrlA?.runtime);
+            applyModelParams(global.ctrlB?.runtime);
+            applyModelParams(global.ctrlC?.runtime);
+            res.json({ success: true, params: currentModelParams });
+        } catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+
+    // 启动web服务器
+    app.listen(global.config.masterPortOfMain, () => {
+        console.log(`\nAI system running on port ${global.config.masterPortOfMain}`);
+        console.log(`API available at http://localhost:${global.config.masterPortOfMain}/api/`);
+    });
+    // 启动Redis客户端
+    redisClient.on('error', (err) => {
+        console.error('Redis error:', err);
+    });
+    redisClient.on('connect', () => {
+        console.log('Connected to Redis');
+    });
+    await redisClient.connect();
+
+    // 启动交错学习调度
+    scheduleCrossLearning();
+
+    // 设置退出保存
+    setupExitHandler();
+
+    console.log('已设置交错自主学习定时任务，每200s执行一次');
+}
+
+// 将参数应用到运行时
+// 扩展 applyModelParams
+function applyModelParams(runtime) {
+    if (!runtime) return;
+    runtime.MAX_MEME_WORDS = currentModelParams.maxMemeWords;
+    runtime.MIN_OVERLAP = currentModelParams.minOverlapThreshold;
+    runtime.config = runtime.config || {};
+    runtime.config.decayFactor = currentModelParams.decayFactor;
+    runtime.config.decayK = currentModelParams.decayK;
+    runtime.config.maxLen = currentModelParams.maxLen;
+    runtime.config.learningIterations = currentModelParams.learningIterations;
+    runtime.config.iteration = currentModelParams.iteration;
+    runtime.config.threshold = currentModelParams.threshold;
+    runtime.config.decay = currentModelParams.decay;
+    // memeBarrier
+    if (runtime.memeBarrier) {
+        runtime.memeBarrier.maliciousThreshold = currentModelParams.maliciousThreshold;
+    }
+    // GraphDB边权重（如需全局调整，可遍历所有边）
+    if (runtime.graph && currentModelParams.edgeWeight !== undefined) {
+        for (const point of runtime.graph.getAllPoints()) {
+            for (const conn of point.connect) {
+                conn[0] = currentModelParams.edgeWeight;
+            }
+        }
+    }
+    console.log('[PARAMS] 已更新运行时参数:', currentModelParams);
+}
+// 如果直接运行此文件，启动主函数
+if (require.main === module) {
+    /*antiTrigger(
+        () => main().catch(console.error), // onContinue
+        () => {
+            // onExit: 保存数据
+            try {
+                if (global.ctrl && global.ctrl.runtime) saveAll(global.ctrl.runtime);
+            } catch (e) { }
+        }
+    );
+    */
+    main().catch(console.error)
+}
+
+module.exports = {
+    Runtime,
+    GraphDB,
+    KVM,
+    controller,
+    main,
+};