079project 1.0.0

package/main_Serve.cjs

@@ -0,0 +1,2745 @@
+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;
+// main_Serve.cjs 中添加
+const workerpool = require('workerpool');
+const csvParse = require('csv-parse/sync')
+// 在文件顶部修改工作池配置
+const os = require('os');
+const MAX_WORKERS = Math.max(1, os.cpus().length - 1); // 留一个核心给主线程
+const natural = require('natural');
+const STOP_WORDS = natural.stopwords; // 英文停用词
+const pool = workerpool.pool(path.join(__dirname, 'memeMergeWorker.cjs'), {
+    minWorkers: 1,
+    maxWorkers: MAX_WORKERS,
+    workerType: 'process'
+});
+
+console.log(`[WORKERS] 工作池已创建，最大工作进程数: ${MAX_WORKERS}`);
+
+protobuf.load(runtimeProtoPath, (err, root) => {
+    if (err) throw err;
+    RuntimeMessage = root.lookupType('Runtime');
+});
+// 全局配置
+global.config = {
+    masterPortOfSql: 3125,
+    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 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);
+    }
+}
+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 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.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 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: this.runtime.kvm.exportEntries(),
+                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()
+        }));
+    }
+
+    deleteSnapshot(snapshotId) {
+        const index = this.snapshotList.findIndex(s => s.id === snapshotId);
+        if (index === -1) {
+            console.error(`[SNAPSHOT] 快照不存在: ${snapshotId}`);
+            return false;
+        }
+
+        const snapshot = this.snapshotList[index];
+        try {
+            // 添加文件存在检查
+            if (fs.existsSync(snapshot.path)) {
+                fs.unlinkSync(snapshot.path);
+                this.snapshotList.splice(index, 1);
+                console.log(`[SNAPSHOT] 已删除快照: ${snapshotId}`);
+                return true;
+            } else {
+                // 如果文件不存在，只从列表中移除
+                this.snapshotList.splice(index, 1);
+                console.log(`[SNAPSHOT] 快照文件不存在，已从列表移除: ${snapshotId}`);
+                return true;
+            }
+        } catch (e) {
+            console.error(`[SNAPSHOT] 删除快照失败: ${snapshotId}`, e);
+            return false;
+        }
+    }
+
+    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 GraphDB {
+    // 点格式：{pointID, connect: [[lineweight, pointID, 0|1|2], ...]}
+    // 0: 双向，1: 指向自己，2: 指向对方
+    constructor() {
+        this.points = new Map();
+    }
+    /**
+     * 添加专门的单向边
+     * @param {string} fromID - 起点ID
+     * @param {string} toID - 终点ID  
+     * @param {number} weight - 边权重
+     * @param {number} specificDirection - 具体方向类型(1=指向自己,2=指向对方)
+     */
+    // 优化 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}`);
+        }
+    }
+
+    /**
+     * 添加双向边（优化版）
+     * @param {string} pointA - 点A的ID
+     * @param {string} pointB - 点B的ID
+     * @param {number} weight - 边权重
+     */
+    addBidirectionalEdge(pointA, pointB, weight = 1) {
+        this.addPoint(pointA);
+        this.addPoint(pointB);
+
+        const safeWeight = (typeof weight === 'number' && isFinite(weight)) ? weight : 1;
+
+        // 检查A到B的边
+        const pointAObj = this.points.get(pointA);
+        if (!pointAObj.connect.some(([w, id, d]) => id === pointB && d === 0)) {
+            pointAObj.connect.push([safeWeight, pointB, 0]);
+        }
+
+        // 检查B到A的边
+        const pointBObj = this.points.get(pointB);
+        if (!pointBObj.connect.some(([w, id, d]) => id === pointA && d === 0)) {
+            pointBObj.connect.push([safeWeight, pointA, 0]);
+        }
+    }
+    // 添加一个点，如果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 {
+    // this KVM is the key-value memory
+    constructor() {
+        // 优先使用 LMDB 做“伪内存映射”后备；失败则回退到内存Map
+        this.memory = new Map();
+        this.useLMDB = false;
+        this.env = null;
+        this.db = null;
+        try {
+            // 延迟加载，避免环境不存在时报错
+            const lmdb = require('lmdb');
+            const storeDir = path.join(__dirname, 'kvm_store');
+            if (!fs.existsSync(storeDir)) fs.mkdirSync(storeDir, { recursive: true });
+            this.env = lmdb.open({
+                path: storeDir,
+                mapSize: 1024n * 1024n * 1024n * 64n, // 64 GiB 地址空间（按需分配，文件后备）
+                compression: true,
+            });
+            this.db = this.env; // 简化：默认数据库
+            this.useLMDB = true;
+            console.log('[KVM] 已启用 LMDB 作为文件映射后备存储');
+        } catch (e) {
+            console.log('[KVM] 未安装 lmdb 或初始化失败，回退为内存Map:', e.message);
+        }
+    }
+
+    get(key) {
+        if (this.useLMDB) {
+            try {
+                const v = this.db.get(key);
+                return Array.isArray(v) ? v : (v ? JSON.parse(v) : undefined);
+            } catch (_) {
+                return undefined;
+            }
+        }
+        return this.memory.get(key);
+    }
+
+    set(key, value) {
+        if (this.useLMDB) {
+            try {
+                const v = Array.isArray(value) || typeof value === 'object' ? JSON.stringify(value) : value;
+                this.db.put(key, v);
+                return;
+            } catch (e) {
+                // 回退一次
+                this.useLMDB = false;
+                console.warn('[KVM] LMDB 写入失败，回退为内存Map:', e.message);
+            }
+        }
+        this.memory.set(key, value);
+    }
+    delete(key) {
+        if (this.useLMDB) {
+            try { this.db.remove(key); } catch (_) {}
+            return;
+        }
+        this.memory.delete(key);
+    }
+    // 用于快照导出，避免直接访问内部实现
+    exportEntries() {
+        if (this.useLMDB) {
+            try {
+                const out = [];
+                for (const k of this.db.getKeys({ snapshot: true })) {
+                    let v = this.db.get(k);
+                    if (typeof v === 'string') {
+                        try { v = JSON.parse(v); } catch (_) {}
+                    }
+                    out.push([k, v]);
+                }
+                return out;
+            } catch (_) {
+                return [];
+            }
+        }
+        return Array.from(this.memory.entries());
+    }
+}
+
+class Changer {
+    //this is a class that focusing on transform the points data with the lines
+    //into the form of tensor and save in the devilfishdbms using ExecuteSql
+    constructor() {
+        // 初始化
+    }
+}
+
+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 方法
+    lemmatizeWords(words) {
+        return Array.isArray(words) ? words.map(w => this.lemmatize(w)) : [];
+    }
+
+    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 {
+    // 运行时负责AI核心的调度、模因转换、信号传递与主流程控制
+    constructor(config = {}) {
+        this.config = config;
+        this.graph = new GraphDB();
+        this.wordGraph = new GraphDB();
+        this.kvm = new KVM();
+        this.changer = new Changer();
+        this.transformer = null;
+        this.vocabManager = global.vocabmanager;
+        this.spider = new Spider();
+        this.wordAccessLog = new Map();
+        this.initWordGraph();
+        this.MAX_MEME_WORDS = 100; // 单个模因最大词数
+        this.MIN_OVERLAP = 2;      // 至少有2个词重叠才允许合并
+        // Runtime类内新增
+        this.activationStats = new Map(); // 记录激活关系
+        // 添加系统资源监控
+        this.systemLoad = {
+            lastCpuUsage: process.cpuUsage(),
+            lastCheckTime: Date.now(),
+            currentLoad: 0,
+            batchSizeMultiplier: 1
+        };
+        this.memeBarrier = new memeBarrier(this);
+    }
+    // 新增资源监控方法
+    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;
+    }
+
+    // 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); // 尝试分裂
+            }
+        }
+    }
+
+    // 在每轮信号扩散后，记录激活链
+    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);
+    }
+
+
+
+    // 初始化词语网络（建立基本的词语关系）
+    // 初始化词语网络（建立基本的词语关系）
+    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, words: memeWords });
+        }
+
+        // 只选覆盖率>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, activationTypes } = this.propagateSignalMultiSource(
+            startIDs,
+            strengths,
+            0.5,
+            3,  // 增加步数以提高语义范围
+            {
+                trackPath: true,
+                directionalMultiplier: 0.7,  // 有向连接衰减较慢，语义流更清晰
+                bidirectionalMultiplier: 1.1  // 双向连接稍快衰减
+            }
+        );
+
+        // 3. 按信号强度排序，同时考虑连接方向
+        const sortedMemes = Array.from(signalMap.entries())
+            .sort((a, b) => {
+                const aID = a[0], bID = b[0];
+                const aTypes = activationTypes?.get(aID);
+                const bTypes = activationTypes?.get(bID);
+
+                // 优先考虑通过单向连接激活的节点（语义流更准确）
+                const aDirectional = aTypes && (aTypes.has(1) || aTypes.has(2)) && !aTypes.has(0);
+                const bDirectional = bTypes && (bTypes.has(1) || bTypes.has(2)) && !bTypes.has(0);
+
+                if (aDirectional && !bDirectional) return -1;
+                if (!aDirectional && bDirectional) return 1;
+
+                // 其次按信号强度排序
+                return b[1] - a[1];
+            })
+            .map(([id]) => id);
+
+        // 4. 收集词语，保持平衡的词汇组合
+        let directionalWords = [];  // 来自单向连接的词
+        let bidirectionalWords = []; // 来自双向连接的词
+
+        for (const memeID of sortedMemes) {
+            const words = this.kvm.get(memeID) || [];
+            const types = activationTypes?.get(memeID);
+
+            if (types && !types.has(0) && (types.has(1) || types.has(2))) {
+                // 来自单向连接的词（更符合语义流向）
+                directionalWords.push(...words);
+            } else {
+                // 来自双向连接的词（概念相关性）
+                bidirectionalWords.push(...words);
+            }
+        }
+
+        // 平衡组合，优先使用单向词，但保证多样性
+        const responseWords = [];
+
+        // 优先添加一些单向词（语义流）
+        const uniqueDirectional = Array.from(new Set(directionalWords));
+        responseWords.push(...uniqueDirectional.slice(0, Math.floor(maxLen * 0.7)));
+
+        // 用双向词补充剩余空间
+        const uniqueBidirectional = Array.from(new Set(bidirectionalWords))
+            .filter(w => !responseWords.includes(w)); // 避免重复
+
+        responseWords.push(
+            ...uniqueBidirectional.slice(0, maxLen - responseWords.length)
+        );
+
+        // 如果还有空间，继续添加单向词
+        if (responseWords.length < maxLen && uniqueDirectional.length > Math.floor(maxLen * 0.7)) {
+            responseWords.push(
+                ...uniqueDirectional.slice(Math.floor(maxLen * 0.7), maxLen - responseWords.length)
+            );
+        }
+
+        // 去重并确保不超过长度限制
+        const finalWords = Array.from(new Set(responseWords)).slice(0, maxLen);
+
+        if (finalWords.length === 0) return '（没有相关记忆）';
+        return finalWords.join(' ');
+    }
+    filterStopWords(words) {
+        return words.filter(word => !STOP_WORDS.includes(word.toLowerCase()));
+    }
+    // 处理自然语言输入（wordsArr为分好词的数组）
+    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);
+    }
+    /**
+     * 多源信号扩散（优化版 - 支持有向连接）
+     * @param {Array<string>} startIDs - 多个起点ID
+     * @param {Array<number>} strengths - 各起点信号强度
+     * @param {number} decayK - 衰减系数
+     * @param {number} maxStep - 最大扩散步数
+     * @param {Object} options - 可选参数
+     *        options.maxActiveNodes: 每步最大活跃节点数
+     *        options.minSignal: 信号强度低于此值不再传播
+     *        options.trackPath: 是否记录激活路径
+     *        options.directionalMultiplier: 单向连接的衰减倍率
+     *        options.bidirectionalMultiplier: 双向连接的衰减倍率
+     * @returns {Object|Map} 激活结果
+     */
+    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 directionalMultiplier = options.directionalMultiplier || 0.7; // 单向连接的衰减倍率（较慢）
+        const bidirectionalMultiplier = options.bidirectionalMultiplier || 1.2; // 双向连接的衰减倍率（较快）
+
+        // 节点信号累加表
+        const signalMap = new Map();
+        // 路径追踪表（可选）
+        const activationPaths = trackPath ? new Map() : null;
+        // 记录节点激活类型
+        const activationTypes = trackPath ? new Map() : null;
+
+        // 初始化活跃队列，每个元素{id, value, from, connectionType}
+        let active = startIDs.map((id, i) => ({
+            id,
+            value: strengths[i],
+            from: null,
+            connectionType: -1  // 起点无连接类型
+        }));
+
+        let step = 0;
+
+        while (active.length > 0 && step < maxStep) {
+            // 限制活跃节点数，优先保留信号强的
+            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, connectionType } of active) {
+                if (value < minSignal) continue;
+
+                // 信号融合：累加到signalMap
+                signalMap.set(id, (signalMap.get(id) || 0) + value);
+
+                // 记录激活类型
+                if (trackPath && connectionType !== -1) {
+                    if (!activationTypes.has(id)) {
+                        activationTypes.set(id, new Set());
+                    }
+                    activationTypes.get(id).add(connectionType);
+                }
+
+                // 路径追踪
+                if (trackPath && from) {
+                    if (!activationPaths.has(id)) {
+                        activationPaths.set(id, []);
+                    }
+                    activationPaths.get(id).push({ from, connectionType, value });
+                }
+
+                // 传播到邻居（考虑连接方向）
+                const point = this.graph.points.get(id);
+                if (!point) continue;
+
+                // 限制每个节点最多处理的邻居数量
+                const MAX_NEIGHBORS = 30;
+                const neighbors = point.connect.slice(0, MAX_NEIGHBORS);
+
+                for (const [weight, neighborID, direction = 0] of neighbors) {
+                    // 根据连接类型决定衰减系数
+                    let effectiveDecay = decayK;
+
+                    if (direction === 0) {
+                        // 双向连接 - 衰减较大（语义关联较弱）
+                        effectiveDecay *= bidirectionalMultiplier;
+                    } else {
+                        // 单向连接 - 衰减较小（语义流向强）
+                        effectiveDecay *= directionalMultiplier;
+                    }
+
+                    // 计算传播后的信号强度
+                    const nextValue = value - effectiveDecay * weight;
+
+                    // 仅当信号足够强时才继续传播
+                    if (nextValue >= minSignal) {
+                        next.push({
+                            id: neighborID,
+                            value: nextValue,
+                            from: id,
+                            connectionType: direction
+                        });
+                    }
+                }
+            }
+            active = next;
+            step++;
+        }
+
+        // 返回结果，根据跟踪路径选项决定返回格式
+        if (trackPath) {
+            return {
+                signalMap,
+                activationPaths,
+                activationTypes
+            };
+        }
+
+        return signalMap;
+    }
+
+    // 主循环：持续归纳和信号传递
+    // 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条
+
+        // 强制GC (如果环境支持)
+        if (global.gc) {
+            global.gc();
+            console.log('[MEMORY] 已触发垃圾回收');
+        } else {
+            console.log('[MEMORY] 垃圾回收不可用，请使用 --expose-gc 启动');
+        }
+    }
+    // Runtime类内
+    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));
+            // 当 CPU > 80% 时，将一个“周期”拆分为两个半周期，中间让出事件循环，避免长阻塞
+            const cpuNow = this.systemLoad.currentLoad || 0;
+            const splitCycle = cpuNow > 80;
+
+            // 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(
+                            pool.exec('calcMemeDistance', [{ wordsA, wordsB }])
+                                .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
+                        );
+                    }
+
+                    // CPU 高负载情况下，每处理完一批就让出一次事件循环
+                    if (splitCycle) {
+                        await new Promise((r) => setImmediate(r));
+                    }
+                }
+            }
+
+            // 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类内
+    // 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.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.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.delete(memeID);
+     //       console.log(`[SPLIT] 删除原模因: ${memeID}`);
+        }
+    }
+}
+
+// 强化学习模块
+
+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} 评分极高，标记为恶性`);
+            // 标记为恶性模因
+            this.runtime.kvm.set(`malicious_${memeID}`, {
+                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);
+    }
+
+    // 启动主循环
+    startMainLoop() {
+        this.runtime.runMainLoop();
+    }
+    // 添加快照相关方法
+    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);
+    }
+
+}
+
+
+
+// 保存所有点、图、词表等到硬盘
+function saveAll(runtime) {
+    const data = {
+        memes: runtime.graph.getAllPoints(),
+        wordGraph: Array.from(runtime.wordGraph.points.values()),
+    kvm: runtime.kvm.exportEntries(),
+        vocab: runtime.vocabManager.vocab,
+        wordAccessLog: Array.from(runtime.wordAccessLog ? runtime.wordAccessLog.entries() : [])
+    };
+    fs.writeFileSync(SAVE_PATH, JSON.stringify(data, null, 2), 'utf-8');
+    console.log(`[SAVE] 系统状态已保存到 ${SAVE_PATH}`);
+}
+
+// 从硬盘恢复
+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);
+        }
+    }
+    if (data.kvm) {
+        for (const [k, v] of data.kvm) {
+            runtime.kvm.set(k, 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} 恢复`);
+}
+
+
+
+// 启动函数
+async function boot() {
+    console.log('Booting AI system...');
+    let model = null;
+
+    try {
+        //model = buildTransformerModel();
+        //await model.compile({ optimizer: 'adam', loss: 'sparseCategoricalCrossentropy' });
+        //console.log('Transformer model initialized');
+
+
+        // === 预训练部分 ===
+        // 加载语料
+        const spider = new Spider();
+        const articles = spider.fetchArticles();
+        let trainInputs = [];
+        let trainLabels = [];
+
+        // 简单按句号分句，只预测每个序列的最后一个词
+        for (const article of articles) {
+            const sentences = article.split(/[.?!;,\n]/);
+            for (const sentence of sentences) {
+                const words = sentence.toLowerCase().split(/\s+/).filter(w => w.length > 0);
+                if (words.length > 1) {
+                    const indices = [global.vocabmanager.word2idx.get('<BOS>'), ...global.vocabmanager.wordsToIndices(words)];
+                    // 只用前n-1做输入，最后一个词做标签
+                    let inputSeq = indices.slice(0, -1);
+                    while (inputSeq.length < 16) inputSeq.push(global.vocabmanager.word2idx.get('<PAD>'));
+                    inputSeq = inputSeq.slice(0, 16);
+                    trainInputs.push(inputSeq);
+                    trainLabels.push(indices[indices.length - 1]);
+                }
+            }
+        }
+
+
+
+    } catch (error) {
+        console.log('Transformer initialization failed:', error.message);
+    }
+
+    console.log('Boot process completed');
+    return model;
+}
+
+// 在main函数末尾添加
+function setupExitHandler() {
+    let isExiting = false;
+
+    const exitHandler = async () => {
+        if (isExiting) return; // 防止重复执行
+        isExiting = 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);
+
+            // 优雅关闭工作池
+            if (pool) {
+                try {
+                    await pool.terminate(true);
+                    console.log('工作池已正常关闭');
+                } catch (err) {
+                    console.error('关闭工作池时出错:', err.message);
+                }
+            }
+        } catch (err) {
+            console.error('关闭过程中出错:', err);
+        }
+        // 给异步操作一点时间完成
+        setTimeout(() => process.exit(0), 1000);
+    };
+
+    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() {
+
+    let spiderPrivate = new Spider();
+    // 创建三个全局控制器副本
+    const ctrlA = new controller();
+    const ctrlB = new controller();
+    const ctrlC = new controller();
+    global.ctrlA = ctrlA;
+    global.ctrlB = ctrlB;
+    global.ctrlC = ctrlC;
+    global.ctrl = ctrlA;
+    // 启动快照自动保存（每30分钟）
+    if (ctrlA.snapshotManager) {
+        ctrlA.snapshotManager.setupAutoSnapshot(30 * 60 * 1000);
+        console.log('[MAIN] 已设置自动快照，每30分钟检查一次');
+    }
+    setupExitHandler();
+    console.log('Starting AI system...');
+    // 恢复各自持久化数据
+    loadAll(ctrlA.runtime);
+    loadAll(ctrlB.runtime);
+    loadAll(ctrlC.runtime);
+    const redisClient = redis.createClient();
+    redisClient.connect();
+    redisClient.on("error", function (err) {
+        console.log("Error " + err);
+    });
+    redisClient.on("connect", function () {
+        console.log("Redis connected");
+    });
+    redisClient.on("ready", function () {
+        console.log("Redis ready");
+    });
+    redisClient.on("end", function () {
+        console.log("Redis disconnected");
+    });
+    redisClient.on("reconnecting", function () {
+        console.log("Redis reconnecting");
+    });
+    redisClient.on("warning", function (warning) {
+        console.log("Redis warning: " + warning);
+    });
+    redisClient.subscribe(`AI-model-${__dirname}`, function (err, msg) {
+        if (err) {
+            console.error("Failed to subscribe to channel:", err);
+        } else {
+            console.log(`Subscribed to channel: AI-model-${__dirname}`);
+        }
+    });
+    redisClient.on("message", function (channel, message) {
+        if (channel === `AI-model-${__dirname}` && RuntimeMessage) {
+            try {
+                // 反序列化为对象
+                const modelObj = RuntimeMessage.decode(Buffer.from(message));
+                // 可选：校验
+                const errMsg = RuntimeMessage.verify(modelObj);
+                if (errMsg) throw Error(errMsg);
+
+                // 将反序列化后的对象同步到 ctrlA.runtime
+                // 你需要实现一个 plainObjToRuntime 方法
+                plainObjToRuntime(ctrlA.runtime, modelObj);
+
+                console.log("[MODEL SYNC] 已同步最新模型到 ctrlA.runtime");
+            } catch (e) {
+                console.error("[MODEL SYNC] 反序列化失败:", e.message);
+            }
+        }
+    });
+
+    // 用A副本初始化语料和模因
+    console.time('articleProcessing');
+    const articles = ctrlA.runtime.buildVocabFromSpider();
+    console.log(`Spider: 加载文章数: ${articles.length}`);
+    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);
+        // 1. 先分句、分词
+        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);
+                }
+            }
+        }
+        // 2. 用workerpool并行归一化
+        const normSentences = await pool.exec('batchLemmatize', [allSentences, lemmaCsvPath]);
+        // 3. 处理
+        for (const normWords of normSentences) {
+            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');
+
+    // 启动主循环（只用A副本）
+    ctrlA.startMainLoop();
+
+    app.post('/api/chat', async (req, res) => {
+        try {
+            const { message } = req.body;
+            // 先分词，再归一化
+            const words = typeof message === 'string'
+                ? message.toLowerCase().split(/\s+/).filter(w => w.length > 0)
+                : [];
+            const normWords = spiderPrivate.lemmatizeWords(words);
+            const normMessage = normWords.join(' ');
+
+      ///      console.log(`[DEBUG] 收到消息: ${message}`);
+      ///      console.log(`[DEBUG] 归一化后: ${normMessage}`);
+
+            const response = await ctrlA.handleInput(normMessage);
+
+            if (!response || response.trim() === '') {
+                console.warn('[WARN] AI响应为空，可能KVM损坏或无记忆');
+            }
+
+     //       console.log(`[DEBUG] 响应: ${response}`);
+            res.json({ response });
+        } catch (error) {
+            console.error('[ERROR] 处理请求失败:', error);
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // 添加健康检查路由
+    app.get('/health', (req, res) => {
+        res.status(200).send('OK');
+    });
+
+    // 添加请求超时中间件
+    app.use((req, res, next) => {
+        // 60秒超时
+        req.setTimeout(60000, () => {
+            res.status(503).json({ error: '处理请求超时' });
+        });
+        next();
+    });
+    app.get('/api/status', (req, res) => {
+        res.json({ status: 'running', timestamp: new Date().toISOString() });
+    });
+
+    // 启动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/`);
+    });
+    // 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 });
+        }
+    });
+    // 启动交错学习调度
+
+
+    // 设置退出保存
+    setupExitHandler();
+
+    console.log('已设置交错自主学习定时任务，每200s执行一次');
+}
+// plainObjToRuntime: 将protobuf对象同步到runtime实例
+// 扩展 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);
+}
+// plainObjToRuntime: 将protobuf对象同步到runtime实例
+async function plainObjToRuntime(runtime, obj) {
+    console.log('[MODEL SYNC] 开始同步模型数据...');
+
+    // 清空原有数据
+    runtime.graph = new GraphDB();
+    runtime.wordGraph = new GraphDB();
+    runtime.kvm = new KVM();
+    runtime.vocabManager.vocab = [];
+    runtime.vocabManager.updateMappings();
+
+    // 加载 memes，确保保留方向信息
+    if (obj.memes) {
+        console.log(`[MODEL SYNC] 同步 ${obj.memes.length} 个模因节点`);
+
+        // 批量处理，避免卡顿
+        const BATCH_SIZE = 500;
+        for (let i = 0; i < obj.memes.length; i += BATCH_SIZE) {
+            const batch = obj.memes.slice(i, i + BATCH_SIZE);
+
+            batch.forEach(meme => {
+                // 手动处理每个连接，确保方向属性被保留
+                const connections = meme.connect.map(c => [
+                    c.weight,
+                    c.pointID,
+                    typeof c.direction !== 'undefined' ? c.direction : 0 // 确保有方向属性
+                ]);
+
+                runtime.graph.addPoint(meme.pointID, connections);
+            });
+
+            // 批处理后让事件循环喘息
+            await new Promise(resolve => setTimeout(resolve, 5));
+        }
+    }
+
+    // 加载 wordGraph，同样保留方向信息
+    if (obj.wordGraph) {
+        console.log(`[MODEL SYNC] 同步 ${obj.wordGraph.length} 个词语节点`);
+
+        const BATCH_SIZE = 1000;
+        for (let i = 0; i < obj.wordGraph.length; i += BATCH_SIZE) {
+            const batch = obj.wordGraph.slice(i, i + BATCH_SIZE);
+
+            batch.forEach(point => {
+                const connections = point.connect.map(c => [
+                    c.weight,
+                    c.pointID,
+                    typeof c.direction !== 'undefined' ? c.direction : 0
+                ]);
+
+                runtime.wordGraph.addPoint(point.pointID, connections);
+            });
+
+            await new Promise(resolve => setTimeout(resolve, 5));
+        }
+    }
+
+    // 加载 kvm
+    if (obj.kvm) {
+        console.log(`[MODEL SYNC] 同步 ${obj.kvm.length} 个键值对`);
+
+        const BATCH_SIZE = 1000;
+        for (let i = 0; i < obj.kvm.length; i += BATCH_SIZE) {
+            const batch = obj.kvm.slice(i, i + BATCH_SIZE);
+
+            batch.forEach(entry => {
+                runtime.kvm.set(entry.key, entry.value);
+            });
+
+            await new Promise(resolve => setTimeout(resolve, 5));
+        }
+    }
+
+    // 加载 vocab
+    if (obj.vocab) {
+        console.log(`[MODEL SYNC] 同步 ${obj.vocab.length} 个词汇`);
+        runtime.vocabManager.vocab = obj.vocab;
+        runtime.vocabManager.updateMappings();
+    }
+
+    console.log('[MODEL SYNC] 模型同步完成');
+}
+
+// 如果直接运行此文件，启动主函数
+// 如果直接运行此文件，启动主函数
+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,
+    boot
+};