079project 2.0.0 → 4.0.0

package/main_Serve.cjs

@@ -18,6 +18,7 @@ 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 { AdversaryScheduler } = require('./schedule.cjs');
 const STOP_WORDS = natural.stopwords; // 英文停用词
 const pool = workerpool.pool(path.join(__dirname, 'memeMergeWorker.cjs'), {
     minWorkers: 1,
@@ -32,28 +33,93 @@ protobuf.load(runtimeProtoPath, (err, root) => {
     RuntimeMessage = root.lookupType('Runtime');
 });
 function parseArgs(argv) {
-  const out = {};
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a && a.startsWith('--')) {
-      const k = a.slice(2);
-      const v = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true;
-      out[k] = v;
-    }
-  }
-  return out;
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a && a.startsWith('--')) {
+            const k = a.slice(2);
+            const v = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true;
+            out[k] = v;
+        }
+    }
+    return out;
 }
 const __args = parseArgs(process.argv.slice(2));
 global.config = {
-  masterPortOfSql: 3125,
-  masterPortOfMain: process.argv[2],
-  emitExitport: process.argv[3] || 8641,
-  groupId: Number(__args['group-id'] || -1),
-  forwarderPort: Number(__args['forwarder-port'] || 0),
-  studyPort: Number(__args['study-port'] || 0),
-  peerServePorts: String(__args['peers'] || '').split(',').map(s => Number(s)).filter(n => Number.isFinite(n) && n > 0),
-  isStudy: !!__args['study']
+    masterPortOfSql: 3125,
+    masterPortOfMain: process.argv[2],
+    emitExitport: process.argv[3] || 8641,
+    groupId: Number(__args['group-id'] || -1),
+    forwarderPort: Number(__args['forwarder-port'] || 0),
+    studyPort: Number(__args['study-port'] || 0),
+    peerServePorts: String(__args['peers'] || '').split(',').map(s => Number(s)).filter(n => Number.isFinite(n) && n > 0),
+    isStudy: !!__args['study']
+};
+// ...existing code...
+const vm = require('vm'); // 新增：沙箱编译
+// ...existing code...
+
+// ==== 内置激活/传递函数注册表 + 安全编译工具 ====
+const BuiltinActivations = {
+    identity: (x) => x,
+    relu: (x) => (x > 0 ? x : 0),
+    leaky_relu: (x) => (x > 0 ? x : 0.01 * x),
+    tanh: (x) => Math.tanh(x),
+    sigmoid: (x) => 1 / (1 + Math.exp(-x)),
+    elu: (x) => (x >= 0 ? x : (Math.exp(x) - 1)),
+    softplus: (x) => Math.log(1 + Math.exp(x)),
+    // 近似 GELU
+    gelu: (x) => 0.5 * x * (1 + Math.tanh(Math.sqrt(2 / Math.PI) * (x + 0.044715 * Math.pow(x, 3))))
+};
+
+const BuiltinTransfers = {
+    // 线性衰减：next = value - decayK*weight*(dirMult)
+    linear: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        return value - (decayK * weight * dm);
+    },
+    // 指数衰减：next = value * exp(-decayK*weight*(dirMult))
+    exp: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        return value * Math.exp(-(decayK * weight * dm));
+    },
+    // 反比例：next = value / (1 + decayK*weight*(dirMult))
+    inverse: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        return value / (1 + (decayK * weight * dm));
+    },
+    // 截断线性：线性后下限截断为0，上限截断为value
+    capped: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        const raw = value - (decayK * weight * dm);
+        return Math.max(0, Math.min(value, raw));
+    }
 };
+
+function compileCustomFunctionSafely(source, argNames, fallback) {
+    try {
+        const ctx = vm.createContext({ Math });
+        // 如果用户提供的是“表达式”，包一层 return
+        const body = source.includes('return') || source.includes('=>') || source.includes('function')
+            ? source
+            : `return (${source});`;
+
+        // 统一包成 function 体
+        const wrapper = `(function(${argNames.join(',')}) { "use strict"; ${body} })`;
+        const script = new vm.Script(wrapper, { timeout: 50 });
+        const fn = script.runInContext(ctx, { timeout: 50 });
+        if (typeof fn !== 'function') return fallback;
+        // 再包一层，避免传入异常导致抛出
+        return (...args) => {
+            try { return fn(...args); } catch (_e) { return fallback(...args); }
+        };
+    } catch (_e) {
+        return fallback;
+    }
+}
+// ...existing code...
+
+// 顶部 modelDefaults 增加参数（与本文件后半段的重复默认值保持一致）
 const modelDefaults = {
     decayFactor: 0.5,
     maxMemeWords: 100,
@@ -65,7 +131,12 @@ const modelDefaults = {
     decay: 1,
     decayK: 1,
     maxLen: 16,
-    edgeWeight: 1
+    edgeWeight: 1,
+    // 新增：激活/传递函数选择与自定义
+    activationType: 'relu',         // identity|relu|leaky_relu|tanh|sigmoid|elu|softplus|gelu|custom
+    transferType: 'linear',         // linear|exp|inverse|capped|custom
+    activationCustom: '',           // 自定义激活函数源码/表达式：f(x) 或 return ...
+    transferCustom: ''              // 自定义传递函数源码/表达式：f(value, weight, decayK, ctx) 或 return ...
 };
 const currentModelParams = { ...modelDefaults };
 // 反触发机制
@@ -265,8 +336,8 @@ class SnapshotManager {
         }
     }
 
+
     async createSnapshot(name = 'auto') {
-        // 防止并发创建
         if (this.isCreatingSnapshot) {
             console.log('[SNAPSHOT] 另一个快照正在创建中，跳过');
             return null;
@@ -282,31 +353,39 @@ class SnapshotManager {
 
             console.log(`[SNAPSHOT] 开始创建快照: ${snapshotId}`);
 
-            // 准备快照数据，分批处理以优化性能
+            // 优先使用分区图的全量导出（避免仅导出窗口）
+            let memesAll = [];
+            if (this.runtime.graph && typeof this.runtime.graph.exportAllPoints === 'function') {
+                try {
+                    memesAll = await this.runtime.graph.exportAllPoints();
+                } catch (e) {
+                    console.warn('[SNAPSHOT] 分区图导出失败，回退窗口:', e.message);
+                    memesAll = this.runtime.graph.getAllPoints();
+                }
+            } else {
+                memesAll = this.runtime.graph.getAllPoints();
+            }
+
             const snapshotData = {
                 id: snapshotId,
                 timestamp,
                 name,
                 createDate: new Date().toISOString(),
-                memes: this.runtime.graph.getAllPoints(),
+                memes: memesAll,
                 wordGraph: Array.from(this.runtime.wordGraph.points.values()),
-                kvm: this.runtime.kvm.exportEntries(),
+                kvm: Array.from(this.runtime.kvm.memory.entries()),
                 vocab: this.runtime.vocabManager.vocab,
-                wordAccessLog: Array.from(this.runtime.wordAccessLog ? this.runtime.wordAccessLog.entries() : [])
+                wordAccessLog: Array.from(this.runtime.wordAccessLog.entries()).map(([w, per]) =>
+                    [w, per instanceof Map ? Array.from(per.entries()) : (Array.isArray(per) ? [['legacy', per.length]] : [])]
+                ),
+                sessions: this.runtime.session.export()
             };
 
-            // 写入临时文件，然后原子重命名以确保数据完整性
             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
-            };
+            const snapshotInfo = { id: snapshotId, timestamp, name, path: filePath };
             this.snapshotList.unshift(snapshotInfo);
 
             console.timeEnd('snapshotCreation');
@@ -320,11 +399,11 @@ class SnapshotManager {
         }
     }
 
+
     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}`);
@@ -332,37 +411,27 @@ class SnapshotManager {
         }
 
         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();
+            // 清空当前运行时（词图/KVM 内存）
             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));
+            // 恢复模因图：走分区导入（覆盖分区存储）
+            if (data.memes && this.runtime.graph && typeof this.runtime.graph.importAllPoints === 'function') {
+                await this.runtime.graph.importAllPoints(data.memes);
+            } else if (data.memes) {
+                // 窗口回退（不推荐）
+                for (const point of data.memes) {
+                    await this.runtime.graph.addPoint(point.pointID, point.connect);
                 }
             }
 
             // 恢复词图
-            console.log('[SNAPSHOT] 恢复词语网络...');
             if (data.wordGraph) {
                 const BATCH_SIZE = 1000;
                 for (let i = 0; i < data.wordGraph.length; i += BATCH_SIZE) {
@@ -375,29 +444,39 @@ class SnapshotManager {
             }
 
             // 恢复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);
-                    }
+                    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);
+                const restored = new Map();
+                for (const [word, per] of data.wordAccessLog) {
+                    if (Array.isArray(per) && per.length > 0 && Array.isArray(per[0])) {
+                        restored.set(word, new Map(per));
+                    } else if (Array.isArray(per)) {
+                        restored.set(word, new Map([['legacy', per.length]]));
+                    } else {
+                        restored.set(word, new Map());
+                    }
+                }
+                this.runtime.wordAccessLog = restored;
+            }
+            if (data.sessions) {
+                this.runtime.session.import(data.sessions);
+            } else {
+                this.runtime.session.startNewSession({ reason: 'snapshot-legacy' });
             }
 
             console.timeEnd('snapshotRestore');
@@ -715,6 +794,727 @@ class GraphDB {
         }
     }
 }
+// ...existing code...
+const crypto = require('crypto');
+// ...existing code...
+
+// ========================== 分区图存储适配层与滑动窗口 ==========================
+
+// 简易日志辅助
+function logPart(...args) { console.log('[PART]', ...args); }
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+// 存储适配层（FS/LMDB/Level 多后端，按需加载）
+class GraphStorageAdapter {
+    constructor({ baseDir, backend = 'fs' } = {}) {
+        this.baseDir = baseDir || path.join(__dirname, 'graph_parts');
+        this.backend = backend;
+        this.ready = false;
+
+        // 尝试创建目录
+        fs.mkdirSync(this.baseDir, { recursive: true });
+
+        // 可选依赖
+        this.lmdb = null;
+        this.level = null;
+
+        if (backend === 'lmdb') {
+            try {
+                this.lmdb = require('lmdb');
+            } catch (e) {
+                console.warn('[PART][ADAPTER] LMDB 不可用，降级为 FS:', e.message);
+                this.backend = 'fs';
+            }
+        }
+        if (backend === 'level') {
+            try {
+                this.level = require('level');
+            } catch (e) {
+                console.warn('[PART][ADAPTER] level 不可用，降级为 FS:', e.message);
+                this.backend = 'fs';
+            }
+        }
+
+        // 初始化后端
+        this._initBackend();
+    }
+
+    _initBackend() {
+        if (this.backend === 'fs') {
+            // FS: 每个分区一个 .jsonl（节点），边界事件一个独立 .jsonl
+            this.ready = true;
+            return;
+        }
+        if (this.backend === 'lmdb' && this.lmdb) {
+            try {
+                const storeDir = path.join(this.baseDir, 'lmdb');
+                fs.mkdirSync(storeDir, { recursive: true });
+                this.env = this.lmdb.open({
+                    path: storeDir,
+                    mapSize: 1024n * 1024n * 1024n * 64n,
+                    compression: true,
+                });
+                this.ready = true;
+            } catch (e) {
+                console.warn('[PART][ADAPTER] LMDB 初始化失败，降级 FS:', e.message);
+                this.backend = 'fs';
+                this.ready = true;
+            }
+            return;
+        }
+        if (this.backend === 'level' && this.level) {
+            try {
+                const dbDir = path.join(this.baseDir, 'leveldb');
+                fs.mkdirSync(dbDir, { recursive: true });
+                this.db = new this.level.Level(dbDir, { valueEncoding: 'json' });
+                this.ready = true;
+            } catch (e) {
+                console.warn('[PART][ADAPTER] level 初始化失败，降级 FS:', e.message);
+                this.backend = 'fs';
+                this.ready = true;
+            }
+            return;
+        }
+        this.ready = true;
+    }
+
+    // 分区文件名（FS）
+    _partFile(pid) { return path.join(this.baseDir, `p_${pid}.jsonl`); }
+    _eventFile(pid) { return path.join(this.baseDir, `p_${pid}.events.jsonl`); }
+
+    // 读取分区（返回 { points: Map<string,{pointID,connect:[]}> }）
+    async loadPartition(pid) {
+        if (this.backend === 'fs') {
+            const file = this._partFile(pid);
+            const out = new Map();
+            if (!fs.existsSync(file)) return { points: out };
+            const rs = fs.createReadStream(file, { encoding: 'utf-8' });
+            let buf = '';
+            for await (const chunk of rs) {
+                buf += chunk;
+                let idx;
+                while ((idx = buf.indexOf('\n')) >= 0) {
+                    const line = buf.slice(0, idx);
+                    buf = buf.slice(idx + 1);
+                    if (!line.trim()) continue;
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj && obj.pointID) {
+                            out.set(obj.pointID, { pointID: obj.pointID, connect: obj.connect || [] });
+                        }
+                    } catch { /* ignore */ }
+                }
+            }
+            return { points: out };
+        }
+
+        if (this.backend === 'lmdb' && this.env) {
+            const points = new Map();
+            const txn = this.env.beginTxn({ readOnly: true });
+            try {
+                const cursor = new this.lmdb.Cursors.Cursor(txn, this.env.openDB({ name: `p_${pid}`, create: true }));
+                for (let found = cursor.goToFirst(); found; found = cursor.goToNext()) {
+                    const key = cursor.getCurrentString();
+                    const val = cursor.getCurrentBinary();
+                    try {
+                        const obj = JSON.parse(Buffer.from(val).toString('utf-8'));
+                        if (obj && obj.pointID) points.set(obj.pointID, obj);
+                    } catch { }
+                }
+                cursor.close();
+            } catch { }
+            txn.abort();
+            return { points };
+        }
+
+        if (this.backend === 'level' && this.db) {
+            const points = new Map();
+            try {
+                for await (const { key, value } of this.db.iterator({ gte: `p:${pid}:`, lt: `p:${pid};` })) {
+                    const obj = value;
+                    if (obj && obj.pointID) points.set(obj.pointID, obj);
+                }
+            } catch { }
+            return { points };
+        }
+
+        return { points: new Map() };
+    }
+
+    // 保存分区（全量覆盖写）
+    async savePartition(pid, pointsMap) {
+        if (!(pointsMap instanceof Map)) return;
+        if (this.backend === 'fs') {
+            const file = this._partFile(pid);
+            const tmp = `${file}.tmp`;
+            const ws = fs.createWriteStream(tmp, { encoding: 'utf-8' });
+            for (const [, p] of pointsMap.entries()) {
+                ws.write(JSON.stringify({ pointID: p.pointID, connect: p.connect || [] }) + '\n');
+            }
+            await new Promise((res, rej) => ws.end(res));
+            await fs.promises.rename(tmp, file);
+            return;
+        }
+
+        if (this.backend === 'lmdb' && this.env) {
+            const dbi = this.env.openDB({ name: `p_${pid}`, create: true });
+            const txn = this.env.beginTxn();
+            try {
+                // 先清空：简化实现
+                const cur = new this.lmdb.Cursors.Cursor(txn, dbi);
+                for (let found = cur.goToFirst(); found; found = cur.goToNext()) {
+                    const k = cur.getCurrentString();
+                    txn.del(dbi, k);
+                }
+                cur.close();
+                for (const [, p] of pointsMap.entries()) {
+                    txn.put(dbi, p.pointID, JSON.stringify(p));
+                }
+                txn.commit();
+            } catch (e) {
+                try { txn.abort(); } catch { }
+                console.warn('[PART][ADAPTER][LMDB] savePartition err:', e.message);
+            }
+            return;
+        }
+
+        if (this.backend === 'level' && this.db) {
+            const ops = [];
+            // 简化：清理旧 key 不容易，直接覆盖同 key
+            for (const [, p] of pointsMap.entries()) {
+                ops.push({ type: 'put', key: `p:${pid}:${p.pointID}`, value: p });
+            }
+            await this.db.batch(ops);
+            return;
+        }
+    }
+
+    // 追加边界事件（跨分区边）
+    async appendEdgeEvent(pid, event) {
+        if (!event || !event.type) return;
+        if (this.backend === 'fs') {
+            const file = this._eventFile(pid);
+            fs.appendFileSync(file, JSON.stringify(event) + '\n', 'utf-8');
+            return;
+        }
+        if (this.backend === 'lmdb' && this.env) {
+            const dbi = this.env.openDB({ name: `e_${pid}`, create: true });
+            const txn = this.env.beginTxn();
+            try {
+                const key = `e:${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+                txn.put(dbi, key, JSON.stringify(event));
+                txn.commit();
+            } catch (e) {
+                try { txn.abort(); } catch { }
+            }
+            return;
+        }
+        if (this.backend === 'level' && this.db) {
+            const key = `e:${pid}:${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+            await this.db.put(key, event);
+            return;
+        }
+    }
+
+    // 读取并消费边界事件（与该分区相关的）
+    async consumeEdgeEvents(pid, filterFn = null, limit = 2000) {
+        const events = [];
+        if (this.backend === 'fs') {
+            const file = this._eventFile(pid);
+            if (!fs.existsSync(file)) return events;
+
+            const tmp = `${file}.tmp`;
+            // 将不消费的事件写入 tmp，再覆盖原文件；已消费事件返回
+            const lines = fs.readFileSync(file, 'utf-8').split(/\r?\n/).filter(Boolean);
+            const remain = [];
+            for (const line of lines) {
+                try {
+                    const e = JSON.parse(line);
+                    const ok = filterFn ? filterFn(e) : true;
+                    if (ok && events.length < limit) {
+                        events.push(e);
+                    } else {
+                        remain.push(line);
+                    }
+                } catch {
+                    remain.push(line);
+                }
+            }
+            fs.writeFileSync(tmp, remain.join('\n') + (remain.length ? '\n' : ''), 'utf-8');
+            await fs.promises.rename(tmp, file);
+            return events;
+        }
+
+        if (this.backend === 'lmdb' && this.env) {
+            const dbi = this.env.openDB({ name: `e_${pid}`, create: true });
+            const txn = this.env.beginTxn();
+            const toDel = [];
+            try {
+                const cur = new this.lmdb.Cursors.Cursor(txn, dbi);
+                for (let found = cur.goToFirst(); found; found = cur.goToNext()) {
+                    const k = cur.getCurrentString();
+                    const v = cur.getCurrentBinary();
+                    const e = JSON.parse(Buffer.from(v).toString('utf-8'));
+                    const ok = filterFn ? filterFn(e) : true;
+                    if (ok && events.length < limit) {
+                        events.push(e);
+                        toDel.push(k);
+                    }
+                }
+                cur.close();
+                for (const k of toDel) txn.del(dbi, k);
+                txn.commit();
+            } catch (e) {
+                try { txn.abort(); } catch { }
+            }
+            return events;
+        }
+
+        if (this.backend === 'level' && this.db) {
+            // 简化：扫描全库 keys 读取该 pid 的事件
+            try {
+                const toDel = [];
+                for await (const { key, value } of this.db.iterator({ gte: `e:${pid}:`, lt: `e:${pid};` })) {
+                    const ok = filterFn ? filterFn(value) : true;
+                    if (ok && events.length < limit) {
+                        events.push(value);
+                        toDel.push(key);
+                    }
+                }
+                // 删除已消费
+                const ops = toDel.map(k => ({ type: 'del', key: k }));
+                if (ops.length) await this.db.batch(ops);
+            } catch { }
+            return events;
+        }
+
+        return events;
+    }
+
+    // 枚举所有分区 ID（FS 模式）
+    async listPartitionIds() {
+        if (this.backend === 'fs') {
+            const files = fs.readdirSync(this.baseDir).filter(f => /^p_\d+\.jsonl$/.test(f));
+            const ids = files.map(f => Number(f.match(/^p_(\d+)\.jsonl$/)[1])).sort((a, b) => a - b);
+            return ids;
+        }
+        // LMDB/level 不易列举，约定 0..N-1 尝试加载
+        return [];
+    }
+}
+
+// 分区器（哈希 -> 分区ID）
+class GraphPartitioner {
+    constructor({ partitions = 64 } = {}) {
+        this.partitions = Math.max(4, partitions);
+    }
+    idOf(pointID) {
+        if (!pointID) return 0;
+        const h = crypto.createHash('sha1').update(String(pointID)).digest();
+        // 使用前 4 字节构造 uint32
+        const u32 = h.readUInt32BE(0);
+        return u32 % this.partitions;
+    }
+    neighborsOf(pid, radius = 1) {
+        const out = new Set([pid]);
+        for (let r = 1; r <= radius; r++) {
+            out.add((pid - r + this.partitions) % this.partitions);
+            out.add((pid + r) % this.partitions);
+        }
+        return Array.from(out).sort((a, b) => a - b);
+    }
+}
+
+// 分区图 + 滑动窗口 + 边界事件消费
+class PartitionedGraphDB {
+    constructor({
+        partitions = 64,
+        maxLoadedPartitions = 8,
+        windowRadius = 1,
+        baseDir = path.join(__dirname, 'graph_parts'),
+        backend = 'fs'
+    } = {}) {
+        this.partitioner = new GraphPartitioner({ partitions });
+        this.adapter = new GraphStorageAdapter({ baseDir, backend });
+        this.maxLoadedPartitions = Math.max(2, maxLoadedPartitions);
+        this.windowRadius = Math.max(0, windowRadius);
+
+        // 已加载分区：pid -> { points: Map, dirty, lastAccess }
+        this.loaded = new Map();
+        // 兼容旧代码：合并视图（仅包含已加载分区的点）
+        this.points = new Map();
+        // LRU
+        this.accessTick = 0;
+        this.centerPid = null;
+
+        // 并发保护
+        this.loading = new Set();
+    }
+
+    // ---------- 内部：加载/保存/淘汰 ----------
+    async ensureLoaded(pid) {
+        if (this.loaded.has(pid)) {
+            this._touch(pid);
+            return this.loaded.get(pid);
+        }
+        if (this.loading.has(pid)) {
+            // 等待已有加载完成
+            while (this.loading.has(pid)) { await sleep(10); }
+            return this.loaded.get(pid);
+        }
+        this.loading.add(pid);
+        try {
+            const part = await this.adapter.loadPartition(pid);
+            const bundle = {
+                points: part.points || new Map(),
+                dirty: false,
+                lastAccess: ++this.accessTick
+            };
+            this.loaded.set(pid, bundle);
+            // 合并到全局视图
+            for (const [id, p] of bundle.points.entries()) this.points.set(id, p);
+
+            // 消费边界事件：把指向本分区的事件落库
+            const events = await this.adapter.consumeEdgeEvents(pid, (e) =>
+                e && e.type === 'cross-edge' && (e.toPid === pid || e.fromPid === pid), 5000);
+            if (events.length) {
+                for (const e of events) this._applyEdgeEvent(bundle, e);
+                bundle.dirty = true;
+            }
+
+            // 控制内存：若超容量，执行淘汰
+            await this._evictIfNeeded();
+            return bundle;
+        } finally {
+            this.loading.delete(pid);
+        }
+    }
+
+    async savePartitionIfDirty(pid) {
+        const entry = this.loaded.get(pid);
+        if (!entry) return;
+        if (!entry.dirty) return;
+        await this.adapter.savePartition(pid, entry.points);
+        entry.dirty = false;
+    }
+
+    async _evictIfNeeded() {
+        if (this.loaded.size <= this.maxLoadedPartitions) return;
+        // 淘汰最近最少访问的分区（除中心窗口）
+        const avoid = new Set(this.partitioner.neighborsOf(this.centerPid ?? 0, this.windowRadius));
+        // 构建按 lastAccess 升序
+        const list = Array.from(this.loaded.entries())
+            .filter(([pid]) => !avoid.has(pid))
+            .sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+        while (this.loaded.size > this.maxLoadedPartitions && list.length) {
+            const [pid, entry] = list.shift();
+            await this.savePartitionIfDirty(pid);
+            // 从全局视图移除
+            for (const [id] of entry.points.entries()) this.points.delete(id);
+            this.loaded.delete(pid);
+            logPart('evicted partition', pid);
+        }
+    }
+
+    _touch(pid) {
+        const entry = this.loaded.get(pid);
+        if (entry) entry.lastAccess = ++this.accessTick;
+    }
+
+    _applyEdgeEvent(targetBundle, e) {
+        // 事件格式：{ type:'cross-edge', from:'id', to:'id', weight, direction, fromPid, toPid }
+        if (!e || e.type !== 'cross-edge') return;
+        const ensurePoint = (m, id) => {
+            if (!m.has(id)) m.set(id, { pointID: id, connect: [] });
+            return m.get(id);
+        };
+        const mp = targetBundle.points;
+        const pFrom = ensurePoint(mp, e.from);
+        const pTo = ensurePoint(mp, e.to);
+        // 在 from 中落边（若 from 属于本分区）
+        if (e.toPid === e.fromPid) {
+            // 同分区事件（理论上不会在事件日志里）
+            if (!pFrom.connect.some(([w, id, d]) => id === e.to && d === e.direction)) {
+                pFrom.connect.push([e.weight, e.to, e.direction]);
+            }
+        } else {
+            // 当前 bundle 即为 toPid 或 fromPid 的载体
+            if (e.toPid === this.partitioner.idOf(pTo.pointID)) {
+                // 对于目标分区，至少要保证可被 selectPath 遍历；保留边终点即可（可选：反向提示边）
+                // 不在 pTo 里写边（避免双写），仅保证 from 的边会在 from 分区生效
+            }
+            if (e.fromPid === this.partitioner.idOf(pFrom.pointID)) {
+                if (!pFrom.connect.some(([w, id, d]) => id === e.to && d === e.direction)) {
+                    pFrom.connect.push([e.weight, e.to, e.direction]);
+                }
+            }
+        }
+    }
+
+    // ---------- 滑动窗口 ----------
+    async focusOnPoint(pointID) {
+        const pid = this.partitioner.idOf(pointID);
+        this.centerPid = pid;
+        const toLoad = this.partitioner.neighborsOf(pid, this.windowRadius);
+        for (const id of toLoad) await this.ensureLoaded(id);
+        await this._evictIfNeeded();
+    }
+
+    // ---------- 兼容 API：点/边 操作 ----------
+    addPoint(pointID, connect = []) {
+        const pid = this.partitioner.idOf(pointID);
+        const ensure = (bundle) => {
+            if (!bundle.points.has(pointID)) bundle.points.set(pointID, { pointID, connect: [] });
+            this.points.set(pointID, bundle.points.get(pointID));
+            return bundle.points.get(pointID);
+        };
+        return this.ensureLoaded(pid).then(bundle => {
+            const p = ensure(bundle);
+            // 添加本地边；跨分区写事件
+            for (const [w, nid, dir] of connect) this._addEdgeInternal(pid, p, w, nid, dir, bundle);
+            bundle.dirty = true;
+        });
+    }
+
+    _addEdgeInternal(fromPid, fromPoint, weight, toID, direction, bundleOfFrom) {
+        const toPid = this.partitioner.idOf(toID);
+        const w = (typeof weight === 'number' && isFinite(weight)) ? weight : 1;
+        const d = (direction === 0 || direction === 1 || direction === 2) ? direction : 0;
+
+        if (toPid === fromPid) {
+            // 同分区直接写
+            if (!fromPoint.connect.some(([ww, id, dd]) => id === toID && dd === d)) {
+                fromPoint.connect.push([w, toID, d]);
+                bundleOfFrom.dirty = true;
+            }
+        } else {
+            // 跨分区 -> 记录边界事件至 fromPid（或 toPid 都可，这里记录到 fromPid，toPid 加载时也会消费相关事件）
+            this.adapter.appendEdgeEvent(fromPid, {
+                type: 'cross-edge',
+                from: fromPoint.pointID,
+                to: toID,
+                weight: w,
+                direction: d,
+                fromPid,
+                toPid
+            });
+            // 同时对“已加载且包含 toPid 的 bundle”进行即时应用（若存在）
+            const toBundle = this.loaded.get(toPid);
+            if (toBundle) {
+                // 在 from 分区已经写入 from->to 事件；对于 to 分区无需写边（避免双写），可选择记录提示（此处略）
+            }
+        }
+    }
+
+    addBidirectionalEdge(id1, id2, weight = 1) {
+        return this.addEdge(id1, id2, weight, 0);
+    }
+
+    async addEdge(fromID, toID, weight = 1, direction = 0) {
+        const fromPid = this.partitioner.idOf(fromID);
+        const fromBundle = await this.ensureLoaded(fromPid);
+        if (!fromBundle.points.has(fromID)) {
+            fromBundle.points.set(fromID, { pointID: fromID, connect: [] });
+            this.points.set(fromID, fromBundle.points.get(fromID));
+        }
+        const fromPoint = fromBundle.points.get(fromID);
+        this._addEdgeInternal(fromPid, fromPoint, weight, toID, direction, fromBundle);
+
+        if (direction === 0) {
+            // 双向边：反向写入
+            const toPid = this.partitioner.idOf(toID);
+            const toBundle = await this.ensureLoaded(toPid);
+            if (!toBundle.points.has(toID)) {
+                toBundle.points.set(toID, { pointID: toID, connect: [] });
+                this.points.set(toID, toBundle.points.get(toID));
+            }
+            const toPoint = toBundle.points.get(toID);
+            this._addEdgeInternal(toPid, toPoint, weight, fromID, 0, toBundle);
+        }
+    }
+
+    async updateEdge(fromID, toID, newWeight, direction = 0) {
+        const fromPid = this.partitioner.idOf(fromID);
+        const b = await this.ensureLoaded(fromPid);
+        const p = b.points.get(fromID);
+        if (!p) return;
+        const idx = p.connect.findIndex(([w, id, d]) => id === toID && d === direction);
+        if (idx >= 0) {
+            p.connect[idx][0] = newWeight;
+            b.dirty = true;
+        } else {
+            // 不存在则添加
+            this._addEdgeInternal(fromPid, p, newWeight, toID, direction, b);
+        }
+    }
+
+    existEdge(fromID, toID) {
+        const fromPid = this.partitioner.idOf(fromID);
+        const entry = this.loaded.get(fromPid);
+        if (!entry) return { exist: false, weight: undefined, type: undefined };
+        const p = entry.points.get(fromID);
+        if (!p) return { exist: false, weight: undefined, type: undefined };
+        const found = p.connect.find(([w, id]) => id === toID);
+        return { exist: !!found, weight: found ? found[0] : undefined, type: found ? found[2] : undefined };
+    }
+
+    existPoint(pointID) {
+        // 仅检查已加载窗口
+        const p = this.points.get(pointID);
+        return { exist: !!p, connect: p ? p.connect : [] };
+    }
+
+    deleteEdge(a, b) {
+        const pid = this.partitioner.idOf(a);
+        const entry = this.loaded.get(pid);
+        if (!entry) return;
+        const p = entry.points.get(a);
+        if (!p) return;
+        const before = p.connect.length;
+        p.connect = p.connect.filter(([_, id]) => id !== b);
+        entry.dirty = entry.dirty || (p.connect.length !== before);
+    }
+
+    deletePoint(pointID) {
+        const pid = this.partitioner.idOf(pointID);
+        const entry = this.loaded.get(pid);
+        if (!entry) return;
+        if (entry.points.has(pointID)) {
+            entry.points.delete(pointID);
+            this.points.delete(pointID);
+            entry.dirty = true;
+        }
+    }
+
+    // 仅遍历窗口内点（兼容旧 getAllPoints 调用）
+    getAllPoints() {
+        return Array.from(this.points.values());
+    }
+
+    // 导出全量点（跨所有分区），用于快照/发布
+    async exportAllPoints() {
+        const out = [];
+        // 尝试枚举 FS 分区；其他后端可按 0..N-1 遍历或仅导出已加载窗口
+        const ids = await this.adapter.listPartitionIds();
+        if (ids.length === 0) {
+            // 回退：导出窗口
+            return this.getAllPoints();
+        }
+        for (const pid of ids) {
+            const part = await this.adapter.loadPartition(pid);
+            for (const [, p] of part.points.entries()) out.push({ pointID: p.pointID, connect: p.connect || [] });
+        }
+        return out;
+    }
+
+    // 批量导入（将 legacy 点集落到分区）
+    async importAllPoints(pointsArr) {
+        if (!Array.isArray(pointsArr)) return;
+        // 分桶
+        const buckets = new Map();
+        for (const p of pointsArr) {
+            const pid = this.partitioner.idOf(p.pointID);
+            if (!buckets.has(pid)) buckets.set(pid, new Map());
+            const bm = buckets.get(pid);
+            bm.set(p.pointID, { pointID: p.pointID, connect: Array.isArray(p.connect) ? p.connect.slice() : [] });
+        }
+        // 写入并更新窗口视图（懒加载）
+        for (const [pid, map] of buckets.entries()) {
+            await this.adapter.savePartition(pid, map);
+            // 若已加载该分区，刷新内存镜像
+            if (this.loaded.has(pid)) {
+                const entry = this.loaded.get(pid);
+                // 从全局视图移除旧
+                for (const [id] of entry.points.entries()) this.points.delete(id);
+                entry.points = map;
+                entry.dirty = false;
+                entry.lastAccess = ++this.accessTick;
+                for (const [id, p] of map.entries()) this.points.set(id, p);
+            }
+        }
+    }
+
+    // 聚合邻居（窗口内），供传播使用
+    getNeighbors(pointID, maxNeighbors = 50) {
+        const p = this.points.get(pointID);
+        if (!p) return [];
+        return p.connect.slice(0, maxNeighbors);
+    }
+
+    // A* 简化：仅在窗口内搜索；跳出窗口时，尝试预取邻接分区后再继续
+    async selectPath(fromID, toID) {
+        if (fromID === toID) return [fromID];
+        // 优先保证焦点加载
+        await this.focusOnPoint(fromID);
+
+        const reconstruct = (came, cur) => {
+            const path = [];
+            let t = cur;
+            while (came.has(t)) { path.push(t); t = came.get(t); }
+            path.push(fromID);
+            return path.reverse();
+        };
+
+        const open = new Set([fromID]);
+        const came = new Map();
+        const g = new Map([[fromID, 0]]);
+        const f = new Map([[fromID, 1]]);
+        const closed = new Set();
+
+        const heuristic = () => 1;
+        let iter = 0;
+        const MAX_ITERS = 5000;
+
+        while (open.size && iter++ < MAX_ITERS) {
+            // 取 f 最小
+            let cur = null; let minF = Infinity;
+            for (const id of open) {
+                const val = f.get(id) ?? Infinity;
+                if (val < minF) { minF = val; cur = id; }
+            }
+            if (cur == null) break;
+            if (cur === toID) return reconstruct(came, cur);
+
+            open.delete(cur);
+            closed.add(cur);
+
+            // 若遇到未知点，尝试加载其分区（滑动窗口）
+            if (!this.points.has(cur)) {
+                await this.focusOnPoint(cur);
+            }
+
+            const neighbors = this.getNeighbors(cur, 50);
+            // 如果邻居为空，尝试边界事件预取（根据邻居 ID 的分区预取）
+            if (neighbors.length === 0) {
+                const pid = this.partitioner.idOf(cur);
+                const ring = this.partitioner.neighborsOf(pid, 1);
+                for (const rid of ring) await this.ensureLoaded(rid);
+            }
+
+            for (const [w, nb] of neighbors) {
+                if (closed.has(nb)) continue;
+                const tentative = (g.get(cur) || Infinity) + w;
+                if (!open.has(nb)) open.add(nb);
+                else if (tentative >= (g.get(nb) || Infinity)) continue;
+
+                came.set(nb, cur);
+                g.set(nb, tentative);
+                f.set(nb, tentative + heuristic());
+            }
+        }
+        return null;
+    }
+
+    // 刷盘所有已加载分区
+    async flushAll() {
+        for (const [pid] of this.loaded.entries()) await this.savePartitionIfDirty(pid);
+    }
+}
+
+// ========================== 替换 Runtime.graph 为分区图 ==========================
+// 说明：wordGraph 仍使用内存 GraphDB；模因图使用 PartitionedGraphDB
+
+// ...existing code...
 
 class KVM {
     // this KVM is the key-value memory
@@ -770,7 +1570,7 @@ class KVM {
     }
     delete(key) {
         if (this.useLMDB) {
-            try { this.db.remove(key); } catch (_) {}
+            try { this.db.remove(key); } catch (_) { }
             return;
         }
         this.memory.delete(key);
@@ -783,7 +1583,7 @@ class KVM {
                 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 (_) {}
+                        try { v = JSON.parse(v); } catch (_) { }
                     }
                     out.push([k, v]);
                 }
@@ -877,7 +1677,17 @@ class Runtime {
     // 运行时负责AI核心的调度、模因转换、信号传递与主流程控制
     constructor(config = {}) {
         this.config = config;
-        this.graph = new GraphDB();
+                // 使用分区图作为模因图；词图仍用内存图
+        this.graph = new PartitionedGraphDB({
+            partitions: this.config.partitions || 64,
+            maxLoadedPartitions: this.config.maxLoadedPartitions || 8,
+            windowRadius: this.config.windowRadius || 1,
+            baseDir: path.join(__dirname, 'graph_parts'),
+            backend: this.config.graphBackend || 'fs' // 可选 'fs' | 'lmdb' | 'level'
+        });
+                this._act = BuiltinActivations.relu;
+        this._transfer = BuiltinTransfers.linear;
+        this._activationMeta = { activationType: 'relu', transferType: 'linear' };
         this.wordGraph = new GraphDB();
         this.kvm = new KVM();
         this.changer = new Changer();
@@ -898,6 +1708,37 @@ class Runtime {
             batchSizeMultiplier: 1
         };
         this.memeBarrier = new memeBarrier(this);
+    }
+        // 获取/设置激活-传递函数配置
+    getActivationConfig() {
+        return {
+            activationType: this._activationMeta.activationType,
+            transferType: this._activationMeta.transferType,
+            activationCustom: this.config?.activationCustom || '',
+            transferCustom: this.config?.transferCustom || ''
+        };
+    }
+
+    setActivationConfig({ activationType, transferType, activationCustom, transferCustom } = {}) {
+        const aType = String(activationType || this._activationMeta.activationType || 'relu');
+        const tType = String(transferType || this._activationMeta.transferType || 'linear');
+
+        let act = BuiltinActivations[aType] || BuiltinActivations.relu;
+        let tr = BuiltinTransfers[tType] || BuiltinTransfers.linear;
+
+        if (aType === 'custom' && activationCustom) {
+            act = compileCustomFunctionSafely(activationCustom, ['x'], BuiltinActivations.relu);
+        }
+        if (tType === 'custom' && transferCustom) {
+            tr = compileCustomFunctionSafely(transferCustom, ['value', 'weight', 'decayK', 'ctx'], BuiltinTransfers.linear);
+        }
+
+        this._act = (typeof act === 'function') ? act : BuiltinActivations.relu;
+        this._transfer = (typeof tr === 'function') ? tr : BuiltinTransfers.linear;
+        this._activationMeta = { activationType: aType, transferType: tType };
+        this.config = this.config || {};
+        this.config.activationCustom = activationCustom || this.config.activationCustom || '';
+        this.config.transferCustom = transferCustom || this.config.transferCustom || '';
     }
     // 新增资源监控方法
     monitorSystemLoad() {
@@ -1059,19 +1900,15 @@ class Runtime {
                 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 });
-                        }
+                // 改为通过 graph.getNeighbors 访问（窗口内）
+                const neighbors = this.graph.getNeighbors(id, 50);
+                for (const [weight, neighborID] of neighbors) {
+                    if (!visited.has(neighborID)) {
+                        next.push({ id: neighborID, value: value - decayK * weight });
                     }
                 }
             }
@@ -1188,7 +2025,7 @@ class Runtime {
     processInput(wordsArr, { addNewWords = true } = {}) {
         wordsArr = this.filterStopWords(wordsArr);
         if (wordsArr.length === 0) { console.log('[FILTER] 输入全为停用词，已全部过滤'); return; }
-       // console.log('Processing input:', wordsArr);
+        // console.log('Processing input:', wordsArr);
         // 批量处理新词添加
         if (addNewWords) {
             // 一次性检查哪些词不在词表中
@@ -1274,7 +2111,7 @@ class Runtime {
             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}`);
+                //           console.log(`Merged to existing meme: ${minMemeID}`);
             } else {
                 // 创建新模因，使用有向连接
                 const newID = 'meme_' + Date.now();
@@ -1284,9 +2121,9 @@ class Runtime {
                 // 单向连接到最近的模因 (方向:2表示指向对方)
                 if (minMemeID) {
                     this.graph.addDirectionalEdge(newID, minMemeID, minDistance, 2);
-      //              console.log(`[LINK] 新模因 ${newID} 单向连接到最近模因 ${minMemeID}`);
+                    //              console.log(`[LINK] 新模因 ${newID} 单向连接到最近模因 ${minMemeID}`);
                 }
-     //           console.log(`Created new meme: ${newID}`);
+                //           console.log(`Created new meme: ${newID}`);
             }
         } else {
             // 创建新模因
@@ -1297,9 +2134,9 @@ class Runtime {
             // 如果有较近的模因，仍然创建单向连接
             if (minMemeID) {
                 this.graph.addDirectionalEdge(newID, minMemeID, Math.min(minDistance, 5), 2);
-      //          console.log(`[LINK] 新模因 ${newID} 单向连接到最近模因 ${minMemeID}`);
+                //          console.log(`[LINK] 新模因 ${newID} 单向连接到最近模因 ${minMemeID}`);
             }
-    //        console.log(`Created new meme: ${newID}`);
+            //        console.log(`Created new meme: ${newID}`);
         }
     }
     // 新增批量添加边的辅助方法
@@ -1341,95 +2178,65 @@ class Runtime {
      *        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 directionalMultiplier = options.directionalMultiplier || 0.7;
+        const bidirectionalMultiplier = options.bidirectionalMultiplier || 1.2;
+
+        const actFn = this._act || BuiltinActivations.relu;
+        const transferFn = this._transfer || BuiltinTransfers.linear;
 
-        // 节点信号累加表
         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  // 起点无连接类型
+            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);
+                // 节点处应用激活函数（融合累计）
+                const prev = signalMap.get(id) || 0;
+                const merged = actFn(prev + value);
+                signalMap.set(id, merged);
 
-                // 记录激活类型
                 if (trackPath && connectionType !== -1) {
-                    if (!activationTypes.has(id)) {
-                        activationTypes.set(id, new Set());
-                    }
+                    if (!activationTypes.has(id)) activationTypes.set(id, new Set());
                     activationTypes.get(id).add(connectionType);
                 }
-
-                // 路径追踪
                 if (trackPath && from) {
-                    if (!activationPaths.has(id)) {
-                        activationPaths.set(id, []);
-                    }
+                    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;
+                    const ctx = { direction, directionalMultiplier, bidirectionalMultiplier };
+                    const rawNext = transferFn(value, weight, decayK, ctx);
+                    const nextValue = actFn(rawNext);
 
-                    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
-                        });
+                        next.push({ id: neighborID, value: nextValue, from: id, connectionType: direction });
                     }
                 }
             }
@@ -1437,15 +2244,9 @@ class Runtime {
             step++;
         }
 
-        // 返回结果，根据跟踪路径选项决定返回格式
         if (trackPath) {
-            return {
-                signalMap,
-                activationPaths,
-                activationTypes
-            };
+            return { signalMap, activationPaths, activationTypes };
         }
-
         return signalMap;
     }
 
@@ -1616,7 +2417,7 @@ class Runtime {
             this.kvm.delete(memeB.pointID);
             memesToDelete.add(memeB.pointID);
 
-    //        console.log(`Merged memes: ${memeA.pointID} <- ${memeB.pointID}`);
+            //        console.log(`Merged memes: ${memeA.pointID} <- ${memeB.pointID}`);
             // 合并后立即尝试分裂
             this.splitMemeIfNeeded(memeA.pointID);
         } else {
@@ -1633,7 +2434,7 @@ class Runtime {
                 // 如果没有双向边，则添加双向边
                 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})`);
+                    //       console.log(`[LINK] 添加双向边: ${memeA.pointID} <-> ${memeB.pointID} (avgDist=${avgDist})`);
                 }
             }
         }
@@ -1665,14 +2466,14 @@ class Runtime {
                     const newID = newIDs[i];
                     this.graph.addPoint(newID, []);
                     this.kvm.set(newID, chunk);
-    //                console.log(`[SPLIT-FORCE] 新建模因: ${newID} 词数: ${chunk.length}`);
+                    //                console.log(`[SPLIT-FORCE] 新建模因: ${newID} 词数: ${chunk.length}`);
                 }
             }
 
             // 删除原模因
             this.graph.points.delete(memeID);
             this.kvm.delete(memeID);
-     //       console.log(`[SPLIT-FORCE] 删除原模因: ${memeID}`);
+            //       console.log(`[SPLIT-FORCE] 删除原模因: ${memeID}`);
             return;
         }
 
@@ -1721,12 +2522,12 @@ class Runtime {
                 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}`);
+                //       console.log(`[SPLIT] 新建模因: ${newID} 词数: ${comp.length}`);
             }
             // 删除原节点
             this.graph.points.delete(memeID);
             this.kvm.delete(memeID);
-     //       console.log(`[SPLIT] 删除原模因: ${memeID}`);
+            //       console.log(`[SPLIT] 删除原模因: ${memeID}`);
         }
     }
 }
@@ -2153,7 +2954,7 @@ class controller {
         const words = text.toLowerCase().split(' ').filter(w => w.length > 0);
         this.runtime.processInput(words, { addNewWords: false });
         // 用模因网络参与推理
-   //     console.log('[DEBUG] 当前所有模因节点:', this.runtime.kvm.memory);
+        //     console.log('[DEBUG] 当前所有模因节点:', this.runtime.kvm.memory);
         return await this.runtime.generateResponseWithMemes(words);
     }
 
@@ -2217,7 +3018,7 @@ function saveAll(runtime) {
     const data = {
         memes: runtime.graph.getAllPoints(),
         wordGraph: Array.from(runtime.wordGraph.points.values()),
-    kvm: runtime.kvm.exportEntries(),
+        kvm: runtime.kvm.exportEntries(),
         vocab: runtime.vocabManager.vocab,
         wordAccessLog: Array.from(runtime.wordAccessLog ? runtime.wordAccessLog.entries() : [])
     };
@@ -2301,72 +3102,129 @@ async function boot() {
 // 激活副本：从快照加载 ctrlB/ctrlC 并加入轮询
 let activeControllers = []; // 轮询数组
 let rrIdx = 0;
+// 新增：双实例热切换状态
+let servingCtrl = null;   // 当前对外服务的控制器
+let standbyCtrl = null;   // 后台承接 Redis 模型的控制器
+let updatingModel = false;
+let pendingModelObj = null;
+
+function setServingController(ctrl) {
+    servingCtrl = ctrl;
+    activeControllers = [servingCtrl]; // 仅对外暴露一份，避免切换瞬间不一致
+    global.ctrlA = servingCtrl;
+    global.ctrl = servingCtrl;
+}
+
+
+// 替换 getNextController：始终返回当前服务控制器
 function getNextController() {
-  if (!activeControllers.length) return global.ctrlA;
-  const c = activeControllers[rrIdx % activeControllers.length];
-  rrIdx = (rrIdx + 1) % activeControllers.length;
-  return c;
+    if (servingCtrl) return servingCtrl;
+    if (activeControllers.length) return activeControllers[rrIdx % activeControllers.length];
+    return global.ctrlA; // 兜底
+}
+async function ensureStandbyReady() {
+    if (!standbyCtrl) {
+        standbyCtrl = new controller(); // 构造函数会初始化 Runtime
+        // 初始保持与serving词表一致，减少首次同步成本（可选）
+        if (servingCtrl?.runtime?.vocabManager?.vocab?.length) {
+            standbyCtrl.runtime.vocabManager.vocab = [...servingCtrl.runtime.vocabManager.vocab];
+            standbyCtrl.runtime.vocabManager.updateMappings();
+        }
+    }
+    return standbyCtrl;
+}
+
+// 将 protobuf 反序列化对象应用到 standby 并热切换
+async function handleRedisModelSwap(modelObj) {
+    if (updatingModel) {
+        pendingModelObj = modelObj; // 只保留最近一条
+        return;
+    }
+    updatingModel = true;
+    try {
+        const standby = await ensureStandbyReady();
+        // 在 standby 上同步模型
+        await plainObjToRuntime(standby.runtime, modelObj);
+        applyModelParams(standby.runtime);
+
+        // 原子切换：standby 上位，serving 变为 standby
+        const oldServing = servingCtrl;
+        setServingController(standbyCtrl);
+        standbyCtrl = oldServing;
+
+        console.log('[MODEL SYNC] 新模型已在后台准备完毕并无缝切换为在线实例');
+    } catch (e) {
+        console.error('[MODEL SYNC] 后台模型切换失败:', e.message);
+    } finally {
+        updatingModel = false;
+        if (pendingModelObj) {
+            const next = pendingModelObj;
+            pendingModelObj = null;
+            // 递归处理最新一条待处理消息
+            setImmediate(() => handleRedisModelSwap(next));
+        }
+    }
 }
 async function activateReplicasIfNeeded() {
-  if (global.config.isStudy) return; // study 进程不启用副本扩容
-  if (global.ctrlB && global.ctrlC) return; // 已激活
-  try {
-    const loadReplicaByName = async (name) => {
-      const ctrl = new controller();
-      // 为副本单独挂载快照管理器
-      ctrl.snapshotManager = new SnapshotManager(ctrl.runtime);
-      // 在 A 的快照目录中寻找对应 id
-      const smA = global.ctrlA.snapshotManager;
-      smA.loadSnapshotList();
-      const snap = smA.snapshotList.find(s => s.name === name || s.id.endsWith(`_${name}`));
-      if (!snap) {
-        console.warn(`[REPLICA] 未找到快照: ${name}，尝试现生成...`);
-        await smA.createSnapshot(name);
-      }
-      const snap2 = smA.snapshotList.find(s => s.name === name || s.id.endsWith(`_${name}`));
-      if (snap2) {
-        // 直接读取该文件内容并恢复到 ctrl.runtime
-        const dataStr = fs.readFileSync(snap2.path, 'utf-8');
-        const data = JSON.parse(dataStr);
-        // 简单恢复（与 SnapshotManager.restoreSnapshot 类似）
-        ctrl.runtime.graph = new GraphDB();
-        ctrl.runtime.wordGraph = new GraphDB();
-        ctrl.runtime.kvm = new KVM();
-        ctrl.runtime.wordAccessLog = new Map(data.wordAccessLog || []);
-        if (data.memes) for (const p of data.memes) ctrl.runtime.graph.addPoint(p.pointID, p.connect);
-        if (data.wordGraph) for (const p of data.wordGraph) ctrl.runtime.wordGraph.addPoint(p.pointID, p.connect);
-        if (data.kvm) for (const [k, v] of data.kvm) ctrl.runtime.kvm.set(k, v);
-        if (data.vocab) { ctrl.runtime.vocabManager.vocab = data.vocab; ctrl.runtime.vocabManager.updateMappings(); }
-        return ctrl;
-      }
-      return null;
-    };
+    if (global.config.isStudy) return; // study 进程不启用副本扩容
+    if (global.ctrlB && global.ctrlC) return; // 已激活
+    try {
+        const loadReplicaByName = async (name) => {
+            const ctrl = new controller();
+            // 为副本单独挂载快照管理器
+            ctrl.snapshotManager = new SnapshotManager(ctrl.runtime);
+            // 在 A 的快照目录中寻找对应 id
+            const smA = global.ctrlA.snapshotManager;
+            smA.loadSnapshotList();
+            const snap = smA.snapshotList.find(s => s.name === name || s.id.endsWith(`_${name}`));
+            if (!snap) {
+                console.warn(`[REPLICA] 未找到快照: ${name}，尝试现生成...`);
+                await smA.createSnapshot(name);
+            }
+            const snap2 = smA.snapshotList.find(s => s.name === name || s.id.endsWith(`_${name}`));
+            if (snap2) {
+                // 直接读取该文件内容并恢复到 ctrl.runtime
+                const dataStr = fs.readFileSync(snap2.path, 'utf-8');
+                const data = JSON.parse(dataStr);
+                // 简单恢复（与 SnapshotManager.restoreSnapshot 类似）
+                ctrl.runtime.graph = new GraphDB();
+                ctrl.runtime.wordGraph = new GraphDB();
+                ctrl.runtime.kvm = new KVM();
+                ctrl.runtime.wordAccessLog = new Map(data.wordAccessLog || []);
+                if (data.memes) for (const p of data.memes) ctrl.runtime.graph.addPoint(p.pointID, p.connect);
+                if (data.wordGraph) for (const p of data.wordGraph) ctrl.runtime.wordGraph.addPoint(p.pointID, p.connect);
+                if (data.kvm) for (const [k, v] of data.kvm) ctrl.runtime.kvm.set(k, v);
+                if (data.vocab) { ctrl.runtime.vocabManager.vocab = data.vocab; ctrl.runtime.vocabManager.updateMappings(); }
+                return ctrl;
+            }
+            return null;
+        };
 
-    if (!global.ctrlB) global.ctrlB = await loadReplicaByName('replica_B');
-    if (!global.ctrlC) global.ctrlC = await loadReplicaByName('replica_C');
-    activeControllers = [global.ctrlA, ...(global.ctrlB ? [global.ctrlB] : []), ...(global.ctrlC ? [global.ctrlC] : [])];
-    console.log(`[REPLICA] 已激活副本: ${activeControllers.length} 个控制器`);
-  } catch (e) {
-    console.warn('[REPLICA] 激活失败:', e.message);
-  }
+        if (!global.ctrlB) global.ctrlB = await loadReplicaByName('replica_B');
+        if (!global.ctrlC) global.ctrlC = await loadReplicaByName('replica_C');
+        activeControllers = [global.ctrlA, ...(global.ctrlB ? [global.ctrlB] : []), ...(global.ctrlC ? [global.ctrlC] : [])];
+        console.log(`[REPLICA] 已激活副本: ${activeControllers.length} 个控制器`);
+    } catch (e) {
+        console.warn('[REPLICA] 激活失败:', e.message);
+    }
 }
 // 对端探测/反触发：同组任一对端端口死亡则激活副本
 function installPeerFailoverMonitor() {
-  const peers = global.config.peerServePorts || [];
-  if (!Array.isArray(peers) || peers.length === 0) return;
-  const axiosInst = axios.create({ timeout: 1500 });
-  setInterval(async () => {
-    try {
-      const checks = await Promise.all(peers.map(p =>
-        axiosInst.get(`http://127.0.0.1:${p}/health`).then(() => true).catch(() => false)
-      ));
-      const dead = checks.some(ok => !ok);
-      if (dead) {
-        console.warn('[ANTI-TRIGGER] 检测到对端 serve 进程离线，启动副本扩容...');
-        await activateReplicasIfNeeded();
-      }
-    } catch (_) { /* 忽略一次错误 */ }
-  }, 3000);
+    const peers = global.config.peerServePorts || [];
+    if (!Array.isArray(peers) || peers.length === 0) return;
+    const axiosInst = axios.create({ timeout: 1500 });
+    setInterval(async () => {
+        try {
+            const checks = await Promise.all(peers.map(p =>
+                axiosInst.get(`http://127.0.0.1:${p}/health`).then(() => true).catch(() => false)
+            ));
+            const dead = checks.some(ok => !ok);
+            if (dead) {
+                console.warn('[ANTI-TRIGGER] 检测到对端 serve 进程离线，启动副本扩容...');
+                await activateReplicasIfNeeded();
+            }
+        } catch (_) { /* 忽略一次错误 */ }
+    }, 3000);
 }
 
 // 在main函数末尾添加
@@ -2416,23 +3274,23 @@ function setupExitHandler() {
 
 // 预缓存副本快照（不在内存常驻）
 async function preCacheReplicas() {
-  try {
-    if (!global.ctrlA?.snapshotManager) return;
-    const sm = global.ctrlA.snapshotManager;
-    sm.loadSnapshotList();
-    const hasB = sm.getSnapshotList().some(s => s.name.includes('replica_B'));
-    const hasC = sm.getSnapshotList().some(s => s.name.includes('replica_C'));
-    if (!hasB) {
-      console.log('[REPLICA] 预生成 ctrlB 快照(replica_B)...');
-      await sm.createSnapshot('replica_B');
-    }
-    if (!hasC) {
-      console.log('[REPLICA] 预生成 ctrlC 快照(replica_C)...');
-      await sm.createSnapshot('replica_C');
-    }
-  } catch (e) {
-    console.warn('[REPLICA] 预缓存失败:', e.message);
-  }
+    try {
+        if (!global.ctrlA?.snapshotManager) return;
+        const sm = global.ctrlA.snapshotManager;
+        sm.loadSnapshotList();
+        const hasB = sm.getSnapshotList().some(s => s.name.includes('replica_B'));
+        const hasC = sm.getSnapshotList().some(s => s.name.includes('replica_C'));
+        if (!hasB) {
+            console.log('[REPLICA] 预生成 ctrlB 快照(replica_B)...');
+            await sm.createSnapshot('replica_B');
+        }
+        if (!hasC) {
+            console.log('[REPLICA] 预生成 ctrlC 快照(replica_C)...');
+            await sm.createSnapshot('replica_C');
+        }
+    } catch (e) {
+        console.warn('[REPLICA] 预缓存失败:', e.message);
+    }
 }
 // 添加定期垃圾回收帮助函数
 function optimizeMemory() {
@@ -2447,21 +3305,33 @@ function optimizeMemory() {
     }
 }
 async function main() {
+        let __adv = null;
+    if (String(process.env.SERVE_ADV_AUTOSTART || '').toLowerCase() === 'true') {
+        __adv = new AdversaryScheduler(global.ctrlA.runtime, {
+            providerSpec: process.env.SERVE_ADV_MODEL || process.env.ADV_MODEL || 'ollama:llama3:70b',
+            judgeMode: process.env.SERVE_ADV_JUDGE || process.env.ADV_JUDGE || 'heuristic',
+            intervalMs: Number(process.env.SERVE_ADV_INTERVAL || 120_000),
+            batchSize: Number(process.env.SERVE_ADV_BATCH || 2),
+            adjustParams: false // 只记录，不修改服务实例的参数
+        });
+        __adv.start();
+    }
 
     let spiderPrivate = new Spider();
     // 创建三个全局控制器副本
-  const ctrlA = new controller();
-  global.ctrlA = ctrlA;
-  global.ctrl = ctrlA;
-  // 启动快照自动保存（每30分钟）
-  if (ctrlA.snapshotManager) {
-    ctrlA.snapshotManager.setupAutoSnapshot(30 * 60 * 1000);
-    console.log('[MAIN] 已设置自动快照，每30分钟检查一次');
-  }
-  setupExitHandler();
-  console.log('Starting AI system...');
-  // 恢复 ctrlA
-  loadAll(ctrlA.runtime);
+    const ctrlA = new controller();
+    global.ctrlA = ctrlA;
+    global.ctrl = ctrlA;
+    setServingController(ctrlA);
+    // 启动快照自动保存（每30分钟）
+    if (ctrlA.snapshotManager) {
+        ctrlA.snapshotManager.setupAutoSnapshot(30 * 60 * 1000);
+        console.log('[MAIN] 已设置自动快照，每30分钟检查一次');
+    }
+    setupExitHandler();
+    console.log('Starting AI system...');
+    // 恢复 ctrlA
+    loadAll(ctrlA.runtime);
     await preCacheReplicas();
     const redisClient = redis.createClient();
     redisClient.connect();
@@ -2493,19 +3363,13 @@ async function main() {
     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");
+                // 后台准备并切换
+                handleRedisModelSwap(modelObj);
             } catch (e) {
-                console.error("[MODEL SYNC] 反序列化失败:", e.message);
+                console.error("[MODEL SYNC] 反序列化或切换失败:", e.message);
             }
         }
     });
@@ -2556,33 +3420,72 @@ async function main() {
     await ctrlA.handleInput('I like apple');
     await ctrlA.handleInput('I love orange');
     await ctrlA.handleInput('you are good');
-  // 启动主循环（仅 A）
-  ctrlA.startMainLoop();
-
-  // 安装对端监控触发器
-  installPeerFailoverMonitor();
-
-// 替换 /api/chat 为轮询分发（A|B|C）
-app.post('/api/chat', async (req, res) => {
-  try {
-    const { message } = req.body || {};
-    const ctrl = getNextController();
-    // 分词与归一化沿用原逻辑
-    const words = typeof message === 'string'
-      ? message.toLowerCase().split(/\s+/).filter(w => w.length > 0)
-      : [];
-    const normWords = (new Spider()).lemmatizeWords(words);
-    const normMessage = normWords.join(' ');
-    const response = await ctrl.handleInput(normMessage);
-    if (!response || response.trim() === '') {
-      console.warn('[WARN] AI响应为空');
-    }
-    res.json({ response });
-  } catch (error) {
-    console.error('[ERROR] 处理请求失败:', error);
-    res.status(500).json({ error: error.message });
-  }
+    // 启动主循环（仅 A）
+    ctrlA.startMainLoop();
+
+    // 安装对端监控触发器
+    installPeerFailoverMonitor();
+app.get('/api/graph/partitions/status', async (req, res) => {
+    try {
+        const g = global.ctrlA?.runtime?.graph;
+        if (!g || !(g instanceof PartitionedGraphDB)) {
+            return res.json({ ok: true, mode: 'in-memory', loaded: 0 });
+        }
+        const loaded = Array.from(g.loaded.keys());
+        res.json({
+            ok: true,
+            mode: 'partitioned',
+            partitions: g.partitioner.partitions,
+            loaded,
+            maxLoaded: g.maxLoadedPartitions,
+            windowRadius: g.windowRadius,
+            centerPid: g.centerPid
+        });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+app.post('/api/graph/partitions/flush', async (req, res) => {
+    try {
+        const g = global.ctrlA?.runtime?.graph;
+        if (g && g.flushAll) await g.flushAll();
+        res.json({ ok: true });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+app.post('/api/graph/prefetch', async (req, res) => {
+    try {
+        const { node } = req.body || {};
+        const g = global.ctrlA?.runtime?.graph;
+        if (!node || !(g instanceof PartitionedGraphDB)) return res.status(400).json({ ok: false, error: 'node 必填/或非分区图' });
+        await g.focusOnPoint(String(node));
+        res.json({ ok: true });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
 });
+    app.post('/api/chat', async (req, res) => {
+        try {
+            const { message } = req.body || {};
+            const ctrl = getNextController(); // 始终路由到当前服务实例
+            const words = typeof message === 'string'
+                ? message.toLowerCase().split(/\s+/).filter(w => w.length > 0)
+                : [];
+            const normWords = (new Spider()).lemmatizeWords(words);
+            const normMessage = normWords.join(' ');
+            const response = await ctrl.handleInput(normMessage);
+            if (!response || response.trim() === '') {
+                console.warn('[WARN] AI响应为空');
+            }
+            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');
@@ -2668,7 +3571,11 @@ app.post('/api/chat', async (req, res) => {
         decay: 1,               // 新增
         decayK: 1,              // 新增
         maxLen: 16,             // 新增
-        edgeWeight: 1           // 新增，GraphDB默认边权重
+        edgeWeight: 1,          // 新增
+        activationType: 'relu',
+        transferType: 'linear',
+        activationCustom: '',
+        transferCustom: ''
     };
     const currentModelParams = { ...modelDefaults };
 
@@ -2699,18 +3606,85 @@ app.post('/api/chat', async (req, res) => {
             res.status(500).json({ error: err.message });
         }
     });
-    // 启动交错学习调度
+    app.get('/api/adversary/status', (req, res) => {
+        try {
+            res.json({ ok: true, status: __adv ? __adv.getStatus() : { running: false } });
+        } catch (e) {
+            res.status(500).json({ ok: false, error: e.message });
+        }
+    });
 
+    app.post('/api/adversary/start', (req, res) => {
+        try {
+            if (!__adv) __adv = new AdversaryScheduler(global.ctrlA.runtime, { adjustParams: false });
+            __adv.start();
+            res.json({ ok: true, status: __adv.getStatus() });
+        } catch (e) {
+            res.status(500).json({ ok: false, error: e.message });
+        }
+    });
+
+    app.post('/api/adversary/stop', (req, res) => {
+        try { __adv?.stop?.(); res.json({ ok: true }); }
+        catch (e) { res.status(500).json({ ok: false, error: e.message }); }
+    });
+    // 新增：serve 侧参数调优 API（默认不启用自动调参，仅手动设置）
+app.get('/api/tune/get', (req, res) => {
+    try {
+        const rt = global.ctrlA?.runtime;
+        if (!rt) return res.status(500).json({ ok: false, error: 'runtime missing' });
+        res.json({
+            ok: true,
+            params: {
+                decayK: rt.config?.decayK ?? 1,
+                maxLen: rt.config?.maxLen ?? 16,
+                spiderMix: rt.config?.spiderMix ?? { onlineWeight: 0.5, offlineWeight: 0.5 },
+                crawler: {
+                    perQuery: global.__crawler?.__tune_perQuery ?? 8,
+                    maxCrawl: global.__crawler?.__tune_maxCrawl ?? 12
+                }
+            }
+        });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+app.post('/api/tune/set', (req, res) => {
+    try {
+        const rt = global.ctrlA?.runtime;
+        if (!rt) return res.status(500).json({ ok: false, error: 'runtime missing' });
+        const snap = applyServeTunableParams(rt, req.body || {});
+        res.json({ ok: true, snapshot: snap });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+// 可选：服务侧对抗调度保持 adjustParams: false，但允许设置 promptMode/targets
+// ...existing code...
+app.post('/api/adversary/start', (req, res) => {
+    try {
+        if (!__adv) __adv = new AdversaryScheduler(global.ctrlA.runtime, { adjustParams: false });
+        const { promptMode, targetWeights } = req.body || {};
+        if (promptMode) __adv.setPromptMode(promptMode);
+        if (targetWeights) __adv.setTargets(targetWeights);
+        __adv.start();
+        res.json({ ok: true, status: __adv.getStatus() });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.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 || {};
@@ -2721,11 +3695,12 @@ function applyModelParams(runtime) {
     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) {
@@ -2733,7 +3708,20 @@ function applyModelParams(runtime) {
             }
         }
     }
-    console.log('[PARAMS] 已更新运行时参数:', currentModelParams);
+
+    // 新增：激活/传递函数配置
+    runtime.setActivationConfig({
+        activationType: currentModelParams.activationType,
+        transferType: currentModelParams.transferType,
+        activationCustom: currentModelParams.activationCustom,
+        transferCustom: currentModelParams.transferCustom
+    });
+
+    console.log('[PARAMS] 已更新运行时参数:', {
+        ...currentModelParams,
+        activationType: runtime.getActivationConfig().activationType,
+        transferType: runtime.getActivationConfig().transferType
+    });
 }
 // plainObjToRuntime: 将protobuf对象同步到runtime实例
 async function plainObjToRuntime(runtime, obj) {
@@ -2818,9 +3806,32 @@ async function plainObjToRuntime(runtime, obj) {
 
     console.log('[MODEL SYNC] 模型同步完成');
 }
-
-// 如果直接运行此文件，启动主函数
-// 如果直接运行此文件，启动主函数
+function applyServeTunableParams(runtime, partial = {}) {
+    if (!runtime) return null;
+    runtime.config = runtime.config || {};
+    if (partial.spiderMix) {
+        const ow = Math.max(0, Math.min(1, Number(partial.spiderMix.onlineWeight ?? runtime.config.spiderMix?.onlineWeight ?? 0.5)));
+        runtime.config.spiderMix = { onlineWeight: ow, offlineWeight: Math.max(0, Math.min(1, 1 - ow)) };
+    }
+    if (typeof partial.decayK === 'number') runtime.config.decayK = Math.max(0.1, Math.min(2.0, partial.decayK));
+    if (typeof partial.maxLen === 'number') runtime.config.maxLen = Math.max(8, Math.min(64, Math.round(partial.maxLen)));
+    if (typeof partial.edgeWeight === 'number' && runtime.graph) {
+        for (const p of runtime.graph.getAllPoints()) for (const e of p.connect) e[0] = Math.max(0.1, Math.min(5, partial.edgeWeight));
+    }
+    if (global.__crawler) {
+        if (typeof partial.perQuery === 'number') global.__crawler.__tune_perQuery = Math.max(2, Math.min(16, Math.round(partial.perQuery)));
+        if (typeof partial.maxCrawl === 'number') global.__crawler.__tune_maxCrawl = Math.max(2, Math.min(24, Math.round(partial.maxCrawl)));
+    }
+    return {
+        decayK: runtime.config.decayK,
+        maxLen: runtime.config.maxLen,
+        spiderMix: runtime.config.spiderMix || { onlineWeight: 0.5, offlineWeight: 0.5 },
+        crawler: {
+            perQuery: global.__crawler?.__tune_perQuery ?? 8,
+            maxCrawl: global.__crawler?.__tune_maxCrawl ?? 12
+        }
+    };
+}
 if (require.main === module) {
 
     main().catch(console.error)