079project 1.0.0 → 3.0.0

package/main_Study.cjs

@@ -29,7 +29,8 @@ const pool = workerpool.pool(path.join(__dirname, 'memeMergeWorker.cjs'), {
 });
 const natural = require('natural');
 const STOP_WORDS = natural.stopwords; // 英文停用词
-
+const { CrawlerManager } = require('./crawler/index.cjs');
+const { AdversaryScheduler } = require('./schedule.cjs');
 console.log(`[WORKERS] 工作池已创建，最大工作进程数: ${MAX_WORKERS}`);
 protobuf.load(runtimeProtoPath, (err, root) => {
     if (err) throw err;
@@ -54,6 +55,407 @@ const modelDefaults = {
     edgeWeight: 1
 };
 const currentModelParams = { ...modelDefaults };
+// ...existing code...
+
+// 统一发布到 Redis（沿用现有 RuntimeMessage）
+async function publishRuntimeToRedis(runtime) {
+    try {
+        if (!RuntimeMessage) return;
+        if (!redisClient || !redisClient.isOpen) {
+            console.warn('[REDIS] 客户端未连接，跳过发布');
+            return;
+        }
+        const plainObj = runtimeToPlain(runtime);
+        const errMsg = RuntimeMessage.verify(plainObj);
+        if (errMsg) throw Error(errMsg);
+        const message = RuntimeMessage.create(plainObj);
+        const buffer = RuntimeMessage.encode(message).finish();
+        await redisClient.publish(`AI-model-${__dirname}`, buffer);
+        console.log('[REDIS] 已发布运行时状态');
+    } catch (e) {
+        console.warn('[REDIS] 发布失败:', e.message);
+    }
+}
+// ...existing code...
+const crypto = require('crypto');
+// ...existing code...
+
+// 差量复制辅助（递归分区哈希）
+const DELTA = {
+    BUCKET_SIZE: 256,
+    hash(buf) {
+        return crypto.createHash('sha1').update(buf).digest('hex');
+    },
+    hashPoint(point) {
+        if (!point) return '0';
+        const arr = (point.connect || []).slice().sort((a, b) => {
+            if (a[1] !== b[1]) return String(a[1]).localeCompare(String(b[1]));
+            if ((a[2] || 0) !== (b[2] || 0)) return (a[2] || 0) - (b[2] || 0);
+            return (a[0] || 0) - (b[0] || 0);
+        });
+        const buf = Buffer.from(JSON.stringify([point.pointID, arr]));
+        return DELTA.hash(buf);
+    },
+    buildGraphIndex(graph) {
+        const ids = Array.from(graph.points.keys()).sort();
+        const nodeHash = new Map();
+        const buckets = [];
+        for (let i = 0; i < ids.length; i += DELTA.BUCKET_SIZE) {
+            const chunk = ids.slice(i, i + DELTA.BUCKET_SIZE);
+            let acc = '';
+            for (const id of chunk) {
+                const h = DELTA.hashPoint(graph.points.get(id));
+                nodeHash.set(id, h);
+                acc += h;
+            }
+            buckets.push({ start: chunk[0], end: chunk[chunk.length - 1], ids: chunk, hash: DELTA.hash(Buffer.from(acc)) });
+        }
+        const summary = DELTA.hash(Buffer.from(buckets.map(b => b.hash).join('')));
+        return { nodeHash, buckets, summary };
+    },
+    equalArray(a, b) {
+        if (a === b) return true;
+        if (!Array.isArray(a) || !Array.isArray(b)) return false;
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+        return true;
+    }
+};
+
+// 基于递归分区哈希的差量克隆
+async function deltaCloneRuntime(prevClone, srcRuntime) {
+    if (!prevClone) {
+        const clone = new Runtime({ ...srcRuntime.config });
+        clone.registerClone();
+        clone.spider = srcRuntime.spider;
+
+        clone.vocabManager.vocab = [...srcRuntime.vocabManager.vocab];
+        clone.vocabManager.updateMappings();
+
+        for (const [id, p] of srcRuntime.wordGraph.points.entries()) {
+            clone.wordGraph.addPoint(id, Array.isArray(p.connect) ? p.connect.map(e => [...e]) : []);
+        }
+        for (const [id, p] of srcRuntime.graph.points.entries()) {
+            clone.graph.addPoint(id, Array.isArray(p.connect) ? p.connect.map(e => [...e]) : []);
+        }
+        for (const [k, v] of srcRuntime.kvm.memory.entries()) {
+            clone.kvm.set(k, Array.isArray(v) ? [...v] : (v == null ? [] : [String(v)]));
+        }
+
+        clone.__deltaIndexes = {
+            graph: DELTA.buildGraphIndex(clone.graph),
+            wordGraph: DELTA.buildGraphIndex(clone.wordGraph),
+            vocabHash: DELTA.hash(Buffer.from(JSON.stringify(clone.vocabManager.vocab)))
+        };
+        return clone;
+    }
+
+    const clone = prevClone;
+    clone.spider = srcRuntime.spider;
+
+    const srcVocabHash = DELTA.hash(Buffer.from(JSON.stringify(srcRuntime.vocabManager.vocab)));
+    if (!clone.__deltaIndexes || clone.__deltaIndexes.vocabHash !== srcVocabHash) {
+        clone.vocabManager.vocab = [...srcRuntime.vocabManager.vocab];
+        clone.vocabManager.updateMappings();
+    }
+
+    const syncGraph = (cloneGraph, srcGraph, name) => {
+        const prevIdx = (clone.__deltaIndexes && clone.__deltaIndexes[name]) || { nodeHash: new Map(), buckets: [] };
+        const srcIdx = DELTA.buildGraphIndex(srcGraph);
+
+        for (const id of Array.from(cloneGraph.points.keys())) {
+            if (!srcGraph.points.has(id)) cloneGraph.points.delete(id);
+        }
+
+        for (const b of srcIdx.buckets) {
+            const prevBucket = prevIdx.buckets.find(x => x.start === b.start && x.end === b.end && x.ids.length === b.ids.length);
+            if (prevBucket && prevBucket.hash === b.hash) continue;
+            for (const id of b.ids) {
+                const srcPoint = srcGraph.points.get(id);
+                const srcH = srcIdx.nodeHash.get(id);
+                const prevH = prevIdx.nodeHash.get(id);
+                if (srcH === prevH && cloneGraph.points.has(id)) continue;
+                cloneGraph.points.set(id, {
+                    pointID: id,
+                    connect: Array.isArray(srcPoint.connect) ? srcPoint.connect.map(e => [...e]) : []
+                });
+            }
+        }
+
+        clone.__deltaIndexes = clone.__deltaIndexes || {};
+        clone.__deltaIndexes[name] = DELTA.buildGraphIndex(cloneGraph);
+    };
+
+    syncGraph(clone.wordGraph, srcRuntime.wordGraph, 'wordGraph');
+    syncGraph(clone.graph, srcRuntime.graph, 'graph');
+
+    for (const k of Array.from(clone.kvm.memory.keys())) {
+        if (!srcRuntime.kvm.memory.has(k)) clone.kvm.memory.delete(k);
+    }
+    for (const [k, v] of srcRuntime.kvm.memory.entries()) {
+        const nv = Array.isArray(v) ? v : (v == null ? [] : [String(v)]);
+        const ov = clone.kvm.memory.get(k) || [];
+        if (!DELTA.equalArray(ov, nv)) {
+            clone.kvm.set(k, [...nv]);
+        }
+    }
+
+    clone.__deltaIndexes.vocabHash = srcVocabHash;
+    return clone;
+}
+
+// 按需检索器：在用户输入（processInput）时触发网络检索与增量学习
+class OnlineResearcher {
+    constructor(runtime, options = {}) {
+        this.runtime = runtime;
+        this.opts = Object.assign({
+            cooldownMs: 25 * 1000,     // 触发冷却窗口
+            maxCrawl: 8,               // 单次抓取最大页面
+            perQuery: 6,
+            maxEnqueue: 20,
+            minPromptLen: 3,           // 过滤过短提示
+            ingestMinLen: 6,           // ingest 的最小分词长度
+            recentCapacity: 64,        // 近提示去重窗口
+        }, options);
+        this.running = false;
+        this.lastRunAt = 0;
+        this.pendingPrompt = null;
+        this.timer = null;
+        this.recent = new Set();
+        this.recentQueue = [];
+    }
+
+    _normalizePromptFromWords(words) {
+        const ws = (Array.isArray(words) ? words : [])
+            .map(w => String(w || '').toLowerCase().trim())
+            .filter(Boolean);
+        // 去停用词后再判断长度
+        const filtered = this.runtime.filterStopWords ? this.runtime.filterStopWords(ws) : ws;
+        if (filtered.length < this.opts.minPromptLen) return '';
+        // 取前若干关键词，避免提示过长
+        return Array.from(new Set(filtered)).slice(0, 16).join(' ');
+    }
+
+    _seen(key) {
+        if (this.recent.has(key)) return true;
+        this.recent.add(key);
+        this.recentQueue.push(key);
+        if (this.recentQueue.length > this.opts.recentCapacity) {
+            const old = this.recentQueue.shift();
+            this.recent.delete(old);
+        }
+        return false;
+    }
+
+    scheduleFromWords(words) {
+        if (!global.__crawler) return; // 爬虫未初始化时跳过
+        const prompt = this._normalizePromptFromWords(words);
+        if (!prompt) return;
+
+        // 近似去重：同一时间窗内同类提示不重复抓取
+        const key = prompt.slice(0, 64);
+        if (this._seen(key)) return;
+
+        const now = Date.now();
+        const remain = this.opts.cooldownMs - (now - this.lastRunAt);
+
+        // 若正在运行或处于冷却，合并为待执行
+        if (this.running || remain > 0) {
+            this.pendingPrompt = prompt;
+            if (!this.timer) {
+                this.timer = setTimeout(() => {
+                    this.timer = null;
+                    const p = this.pendingPrompt;
+                    this.pendingPrompt = null;
+                    if (p) this._doSearchAndIngest(p);
+                }, Math.max(100, remain));
+            }
+            return;
+        }
+
+        this._doSearchAndIngest(prompt);
+    }
+
+    async _doSearchAndIngest(prompt) {
+        this.running = true;
+        this.lastRunAt = Date.now();
+        try {
+            const report = await global.__crawler.directedSearch(prompt, {
+                vertical: 'general',
+                perQuery: this.opts.perQuery,
+                maxEnqueue: this.opts.maxEnqueue,
+                crawl: true,
+                maxCrawl: this.opts.maxCrawl
+            });
+            // 抓取完成后立即增量学习（只读最近若干文档）
+            const docs = global.__crawler.loadRecentDocs(24);
+            let fed = 0;
+            for (const d of docs) {
+                fed += await this.runtime.ingestTextDocument(d.text, {
+                    addNewWords: true,
+                    minLen: this.opts.ingestMinLen
+                });
+            }
+            if (fed > 0) {
+                this.runtime.updateAttentionLinks();
+                console.log(`[RESEARCH] "${prompt}" 抓取并增量学习完成: fed=${fed}, crawled=${report?.crawled ?? 0}`);
+            } else {
+                console.log(`[RESEARCH] "${prompt}" 未产生有效增量`);
+            }
+        } catch (e) {
+            console.warn('[RESEARCH] 抓取/增量学习失败:', e.message);
+        } finally {
+            this.running = false;
+            // 合并突发多次提示：优先处理最近一次
+            if (this.pendingPrompt) {
+                const p = this.pendingPrompt;
+                this.pendingPrompt = null;
+                this._doSearchAndIngest(p);
+            }
+        }
+    }
+}
+// ...existing code...
+// 轮换管理器：在克隆上训练，评估通过后原子切换，避免占用在线副本
+class RotationManager {
+    constructor(ctrlA, ctrlB, ctrlC, options = {}) {
+        this.ctrlA = ctrlA;
+        this.ctrlB = ctrlB;
+        this.ctrlC = ctrlC;
+        this.isRotating = false;
+        this.timer = null;
+        this.opts = Object.assign({
+            cycleMs: 30 * 60 * 1000,     // 每轮步进间隔：默认30分钟
+            cooldownMs: 60 * 1000,       // 单步完成后的冷却时间
+            learnIters: 3,               // 克隆训练迭代
+            minImprove: 0.005            // 最小收益阈值（0.5%）
+        }, options);
+        this.sequence = [
+            { from: 'A', to: 'B' },
+            { from: 'B', to: 'C' },
+            { from: 'C', to: 'A' }
+        ];
+        this.idx = 0;
+    }
+
+    start() {
+        if (this.timer) return;
+        const runStep = async () => {
+            if (this.isRotating || isShuttingDown) return;
+            this.isRotating = true;
+            try {
+                const step = this.sequence[this.idx % this.sequence.length];
+                await this._runOne(step.from, step.to);
+                this.idx++;
+            } catch (e) {
+                console.warn('[ROTATE] 步骤失败:', e.message);
+            } finally {
+                this.isRotating = false;
+            }
+        };
+        // 立即跑一次，再按周期跑
+        runStep();
+        this.timer = registerInterval(runStep, this.opts.cycleMs);
+        console.log(`[ROTATE] 轮换学习已启动：每${Math.round(this.opts.cycleMs / 60000)}分钟步进一次`);
+    }
+
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+        this.timer = null;
+    }
+
+    _getCtrl(name) {
+        return name === 'A' ? this.ctrlA : (name === 'B' ? this.ctrlB : this.ctrlC);
+    }
+
+    async _runOne(fromName, toName) {
+        const fromCtrl = this._getCtrl(fromName);
+        const toCtrl = this._getCtrl(toName);
+        if (!fromCtrl || !toCtrl) return;
+
+        if (fromCtrl.isLearning || toCtrl.isLearning) {
+            console.log(`[ROTATE] ${fromName} 或 ${toName} 正在学习，跳过本步`);
+            return;
+        }
+
+        console.log(`[ROTATE] ${fromName} -> ${toName} 开始克隆与训练（离线）`);
+
+        // 1) 识别模式 + 克隆
+        const association = new AssociationLayer(fromCtrl.runtime);
+        association.patterns = association.identifyPatterns();
+        const systemClone = await association.cloneSystem();
+        systemClone.spider = fromCtrl.runtime.spider;
+        association.applyPatternsToClone(systemClone);
+
+        // 2) 预热克隆（确保索引、边权等就绪）
+        const sampleWords = Array.from(new Set(systemClone.vocabManager.vocab.slice(4, 64))).filter(w => w.length > 1).slice(0, 16);
+        if (sampleWords.length) {
+            try {
+                await systemClone.processInput(sampleWords, { addNewWords: false });
+            } catch (_) { }
+        }
+
+        // 3) 在克隆上训练而非在线副本
+        try {
+            await systemClone.startSelfLearning(this.opts.learnIters);
+        } catch (e) {
+            console.warn('[ROTATE] 克隆训练失败:', e.message);
+            return;
+        }
+
+        // 4) 评估：对比 from 与 clone
+        const { origScore, cloneScore } = await this._evaluateTwo(fromCtrl.runtime, systemClone);
+        const improve = origScore > 0 ? (cloneScore - origScore) / origScore : (cloneScore > 0 ? 1 : 0);
+
+        console.log(`[ROTATE] 评估：orig=${origScore.toFixed(4)} clone=${cloneScore.toFixed(4)} improve=${(improve * 100).toFixed(2)}%`);
+
+        if (improve >= this.opts.minImprove) {
+            // 5) 提交：原子切换 toCtrl.runtime = clone
+            toCtrl.updateRuntime(systemClone);
+            console.log(`[ROTATE] 已将 ${fromName} 的成果切换到 ${toName}`);
+
+            // 如切到 A，发布到 Redis
+            if (toName === 'A') {
+                await publishRuntimeToRedis(systemClone);
+            }
+        } else {
+            console.log('[ROTATE] 改进不足，放弃本次提交');
+        }
+
+        // 6) 冷却
+        await new Promise(r => setTimeout(r, this.opts.cooldownMs));
+    }
+
+    async _evaluateTwo(baseRuntime, cloneRuntime) {
+        try {
+            // 复用 RL 的评估数据来源与方法
+            const rl = new ReinforcementLearner(baseRuntime);
+            const articles = rl.loadTestArticles();
+            if (!articles.length) {
+                // 无测试集：退化为用词表覆盖率近似
+                const s1 = baseRuntime.vocabManager.getsize();
+                const s2 = cloneRuntime.vocabManager.getsize();
+                return { origScore: s1, cloneScore: s2 };
+            }
+            let origCoverages = 0;
+            let cloneCoverages = 0;
+            for (const article of articles) {
+                origCoverages += rl.evaluateSystem(baseRuntime, article);
+                cloneCoverages += rl.evaluateSystem(cloneRuntime, article);
+            }
+            // 使用“总和-方差的平方根”的稳健度量（与 RL.learn 相同思想）
+            const avgOrig = origCoverages;
+            const avgClone = cloneCoverages;
+            return { origScore: avgOrig, cloneScore: avgClone };
+        } catch (e) {
+            console.warn('[ROTATE] 评估失败，回退到零分:', e.message);
+            return { origScore: 0, cloneScore: 0 };
+        }
+    }
+}
+// ...existing code...
 async function batchAddPoints(graph, pointsArr, batchSize = 500) {
     if (!graph || !pointsArr || !Array.isArray(pointsArr)) {
         console.error('[BATCH] 无效的参数:', {
@@ -79,6 +481,7 @@ async function batchAddPoints(graph, pointsArr, batchSize = 500) {
         await new Promise(resolve => setImmediate(resolve));
     }
 }
+/*
 // 反触发机制
 async function antiTrigger(onContinue, onExit) {
     const PORT = global.config.emitExitport || 8641;
@@ -145,6 +548,7 @@ async function antiTrigger(onContinue, onExit) {
         }, 10000);
     }
 }
+    */
 function verifySystemConsistency(sourceRuntime, targetRuntime) {
     console.log('[VERIFY] 开始验证系统一致性...');
     console.log(`[VERIFY] 源词表大小: ${sourceRuntime.vocabManager.vocab.length}, 目标: ${targetRuntime.vocabManager.vocab.length}`);
@@ -163,12 +567,104 @@ const readline = require('readline');
 
 app.use(bodyParser.json());
 app.use(bodyParser.urlencoded({ extended: true }));
+// ...existing code...
 app.use(express.static(path.join(__dirname, 'public')));
 
 // 持久化路径
 const SAVE_PATH = path.join(__dirname, 'runtime_data.json');
 
-
+// 新增：会话管理器（以对话为尺度管理记忆）
+class SessionManager {
+    constructor({ idleMs = 10 * 60 * 1000, maxSessions = 200 } = {}) {
+        this.idleMs = idleMs;          // 会话空闲超时，自动切新会话
+        this.maxSessions = maxSessions; // 最近保留的会话数量上限（用于遗忘窗口）
+        this.sessions = new Map();      // sessionId -> { start, lastActivity, messageCount }
+        this.current = null;
+    }
+    now() { return Date.now(); }
+    _newId() { return `S${Date.now()}_${Math.floor(Math.random() * 1e6)}`; }
+
+    startNewSession(meta = {}) {
+        const id = this._newId();
+        const ts = this.now();
+        this.sessions.set(id, {
+            start: ts,
+            lastActivity: ts,
+            messageCount: 0,
+            ...meta
+        });
+        this.current = id;
+        this._truncateIfNeeded();
+        return id;
+    }
+    ensureActive() {
+        const ts = this.now();
+        if (!this.current || !this.sessions.has(this.current)) {
+            return this.startNewSession();
+        }
+        const s = this.sessions.get(this.current);
+        if (ts - s.lastActivity > this.idleMs) {
+            return this.startNewSession({ reason: 'idle-timeout' });
+        }
+        return this.current;
+    }
+    useSession(sessionId) {
+        if (!sessionId) return this.ensureActive();
+        if (!this.sessions.has(sessionId)) {
+            const ts = this.now();
+            this.sessions.set(sessionId, { start: ts, lastActivity: ts, messageCount: 0 });
+        }
+        this.current = sessionId;
+        return sessionId;
+    }
+    touch(sessionId = this.current) {
+        if (!sessionId) return;
+        const s = this.sessions.get(sessionId);
+        if (s) s.lastActivity = this.now();
+    }
+    incMessage(sessionId = this.current) {
+        if (!sessionId) return;
+        const s = this.sessions.get(sessionId);
+        if (s) {
+            s.messageCount = (s.messageCount || 0) + 1;
+            s.lastActivity = this.now();
+        }
+    }
+    getActiveSessionId() {
+        return this.ensureActive();
+    }
+    // 返回最近的会话ID（按 lastActivity 降序）
+    getRecentSessionIds(limit = this.maxSessions) {
+        const entries = Array.from(this.sessions.entries());
+        entries.sort((a, b) => (b[1].lastActivity || 0) - (a[1].lastActivity || 0));
+        return entries.slice(0, limit).map(([id]) => id);
+    }
+    _truncateIfNeeded() {
+        const ids = this.getRecentSessionIds(this.maxSessions);
+        const keep = new Set(ids);
+        for (const id of this.sessions.keys()) {
+            if (!keep.has(id)) this.sessions.delete(id);
+        }
+    }
+    export() {
+        return {
+            config: { idleMs: this.idleMs, maxSessions: this.maxSessions },
+            current: this.current,
+            sessions: Array.from(this.sessions.entries())
+        };
+    }
+    import(obj) {
+        if (!obj) return;
+        const { config, current, sessions } = obj;
+        if (config) {
+            this.idleMs = config.idleMs ?? this.idleMs;
+            this.maxSessions = config.maxSessions ?? this.maxSessions;
+        }
+        this.sessions = new Map(Array.isArray(sessions) ? sessions : []);
+        this.current = current || null;
+    }
+}
+// ...existing code...
 
 
 class SnapshotManager {
@@ -206,7 +702,6 @@ class SnapshotManager {
     }
 
     async createSnapshot(name = 'auto') {
-        // 防止并发创建
         if (this.isCreatingSnapshot) {
             console.log('[SNAPSHOT] 另一个快照正在创建中，跳过');
             return null;
@@ -222,31 +717,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: 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');
@@ -260,11 +763,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}`);
@@ -272,37 +775,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) {
@@ -315,29 +808,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');
@@ -645,59 +1148,769 @@ class GraphDB {
                 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;
-                }
+                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);
+        }
+    }
+}
+// 简易日志辅助
+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);
 
-                cameFrom.set(neighborID, current);
-                gScore.set(neighborID, tentativeGScore);
-                fScore.set(neighborID, tentativeGScore + this.heuristic(neighborID, toID));
+        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);
         }
-        return null;
     }
 
-    // 获取所有点
+    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());
     }
 
-    // 启发式函数：简单的常数启发式
-    heuristic(pointID, toID) {
-        return 1; // 简化的启发式函数
+    // 导出全量点（跨所有分区），用于快照/发布
+    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;
     }
-    existEdge(pointID, neighborID) {
-        const point = this.points.get(pointID);
-        if (!point) {
-            return { exist: false, weight: undefined, type: undefined };
+
+    // 批量导入（将 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);
+            }
         }
-        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 || [] };
+
+    // 聚合邻居（窗口内），供传播使用
+    getNeighbors(pointID, maxNeighbors = 50) {
+        const p = this.points.get(pointID);
+        if (!p) return [];
+        return p.connect.slice(0, maxNeighbors);
     }
-    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);
+
+    // 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;
     }
-    deletePoint(pointID) {
-        if (this.existPoint(pointID).exist) {
-            this.points.delete(pointID);
-        }
+
+    // 刷盘所有已加载分区
+    async flushAll() {
+        for (const [pid] of this.loaded.entries()) await this.savePartitionIfDirty(pid);
     }
 }
-
 class KVM {
     constructor() {
         this.memory = new Map();
@@ -795,22 +2008,36 @@ 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 || 'lmdb' // 可选 'fs' | 'lmdb' | 'level'
+        });
         this.wordGraph = new GraphDB();
         this.kvm = new KVM();
 
         this.transformer = null;
         this.vocabManager = global.vocabmanager;
         this.spider = new Spider();
+        // 新：按需检索器（基于全局爬虫）
+        this.researcher = new OnlineResearcher(this);
+        // 新：以“会话”为尺度的访问日志与会话管理
+        this.session = new SessionManager({
+            idleMs: this.config.sessionIdleMs || 10 * 60 * 1000,
+            maxSessions: this.config.memoryRecentSessions || 200
+        });
+        // Map<word, Map<sessionId, count>>
         this.wordAccessLog = new Map();
+                this.config.spiderMix = this.config.spiderMix || { onlineWeight: 0.5, offlineWeight: 0.5 };
         this.initWordGraph();
-        this.forgetTimer = setInterval(() => this.forgetWords(), 350 * 1000);        // 3. 判断是否合并到已有模因
-        this.MAX_MEME_WORDS = 100; // 单个模因最大词数
-        this.MIN_OVERLAP = 2;      // 至少有2个词重叠才允许合并
-        // Runtime类内新增
-        this.activationStats = new Map(); // 记录激活关系
+        this.forgetTimer = setInterval(() => this.forgetWords(), 350 * 1000);
+        this.MAX_MEME_WORDS = 100;
+        this.MIN_OVERLAP = 2;
+        this.activationStats = new Map();
         this.isclone = false;
-        // 添加系统资源监控
         this.systemLoad = {
             lastCpuUsage: process.cpuUsage(),
             lastCheckTime: Date.now(),
@@ -818,12 +2045,61 @@ class Runtime {
             batchSizeMultiplier: 1
         };
         this.memeBarrier = new memeBarrier(this);
+    }
+        // 新增：应用可调参数（含 spiderMix / decayK / maxLen 等）
+    applyTunableParams(partial = {}) {
+        this.config = this.config || {};
+        if (partial.spiderMix) {
+            const ow = Math.max(0, Math.min(1, Number(partial.spiderMix.onlineWeight ?? this.config.spiderMix.onlineWeight ?? 0.5)));
+            this.config.spiderMix = { onlineWeight: ow, offlineWeight: Math.max(0, Math.min(1, 1 - ow)) };
+        }
+        if (typeof partial.decayK === 'number') this.config.decayK = Math.max(0.1, Math.min(2.0, partial.decayK));
+        if (typeof partial.maxLen === 'number') this.config.maxLen = Math.max(8, Math.min(64, Math.round(partial.maxLen)));
+        if (typeof partial.edgeWeight === 'number') {
+            for (const p of this.graph.getAllPoints()) for (const e of p.connect) e[0] = Math.max(0.1, Math.min(5, partial.edgeWeight));
+        }
+        // 可选：调节 crawler 抓取强度（若存在）
+        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: this.config.decayK,
+            maxLen: this.config.maxLen,
+            spiderMix: this.config.spiderMix,
+            crawler: {
+                perQuery: global.__crawler?.__tune_perQuery ?? 8,
+                maxCrawl: global.__crawler?.__tune_maxCrawl ?? 12
+            }
+        };
     }
     // 添加到Runtime类内部
     filterStopWords(words) {
         return words.filter(word => !STOP_WORDS.includes(word.toLowerCase()));
     }
-
+    async ingestTextDocument(raw, { addNewWords = true, minLen = 8 } = {}) {
+        if (!raw) return 0;
+        // 去除 meta，正文在空行后
+        const parts = String(raw).split(/\r?\n\r?\n/);
+        const body = parts.length > 1 ? parts.slice(1).join('\n') : parts[0];
+        const sentences = body.split(/\r?\n+/).map(s => s.trim()).filter(Boolean);
+        let fed = 0;
+        for (const line of sentences) {
+            // 分词 -> 归一化 -> 停用词过滤 -> processInput
+            const words = line
+                .toLowerCase()
+                .replace(/[^a-z\s\u4e00-\u9fa5]/g, ' ')
+                .split(/\s+/)
+                .filter(w => w.length >= 2);
+            if (!words.length) continue;
+            const normalized = this.spider ? this.spider.lemmatizeWords(words) : words;
+            const filtered = this.filterStopWords ? this.filterStopWords(normalized) : normalized;
+            if (filtered.length < minLen) continue;
+            this.processInput(filtered, { addNewWords });
+            fed++;
+        }
+        return fed;
+    }
     // 新增资源监控方法
     monitorSystemLoad() {
         const now = Date.now();
@@ -858,12 +2134,12 @@ class Runtime {
         return this.systemLoad.batchSizeMultiplier;
     }
     // 清理定时器
+    // 清理定时器/刷盘
     cleanup() {
-        if (this.forgetTimer) {
-            clearInterval(this.forgetTimer);
-        }
-        if (this.memeBarrier) {
-            this.memeBarrier.stop();
+        if (this.forgetTimer) clearInterval(this.forgetTimer);
+        if (this.memeBarrier) this.memeBarrier.stop();
+        if (this.graph && this.graph.flushAll) {
+            this.graph.flushAll().catch(() => { });
         }
     }
     // Runtime类中添加监控函数
@@ -872,7 +2148,7 @@ class Runtime {
         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}`);
+                //     console.log(`[MONITOR] 检测到大模因: ${meme.pointID}, 词数: ${words.length}`);
                 this.splitMemeIfNeeded(meme.pointID); // 尝试分裂
             }
         }
@@ -926,12 +2202,14 @@ class Runtime {
     }
 
     // 记录词语点被访问
-    logWordAccess(word) {
-        const now = Date.now();
-        if (!this.wordAccessLog.has(word)) {
-            this.wordAccessLog.set(word, []);
-        }
-        this.wordAccessLog.get(word).push(now);
+    logWordAccess(word, sessionId) {
+        const sid = sessionId || this.session.getActiveSessionId();
+        let perSession = this.wordAccessLog.get(word);
+        if (!perSession) {
+            perSession = new Map();
+            this.wordAccessLog.set(word, perSession);
+        }
+        perSession.set(sid, (perSession.get(sid) || 0) + 1);
     }
     registerClone() {
         Runtime.cloneRegistry.add(this);
@@ -945,56 +2223,59 @@ class Runtime {
         this.kvm.memory.clear();
         if (this.wordAccessLog) this.wordAccessLog.clear();
         if (this.forgetTimer) clearInterval(this.forgetTimer);
-        // 其它属性也可清空
     }
+    // 将遗忘策略改为“最近N个会话窗口”
     forgetWords() {
-        const now = Date.now();
-        const windowMs = 350 * 1000;
-
-        // 只保留窗口内访问
-        for (const [key, times] of this.wordAccessLog.entries()) {
-            const recent = times.filter(t => now - t <= windowMs);
-            this.wordAccessLog.set(key, recent);
-        }
-
         // 保护：收集所有被KVM引用的词
         const protectedWords = new Set();
         for (const [, words] of this.kvm.memory.entries()) {
-            if (Array.isArray(words)) {
-                for (const w of words) protectedWords.add(w);
-            }
+            if (Array.isArray(words)) for (const w of words) protectedWords.add(w);
         }
 
-        // 若词表过小，直接跳过遗忘，避免崩塌
         const vocabSize = this.vocabManager.vocab.length;
         if (vocabSize < 1000) {
             console.log('[FORGET] 词表过小，跳过本轮遗忘');
             return;
         }
 
-        // 仅对“存在于词图且不在保护集”的词做统计
+        const recentSessions = this.session.getRecentSessionIds(this.config.memoryRecentSessions || 200);
+        const recentSet = new Set(recentSessions);
+
         const stats = [];
-        for (const [word, recent] of this.wordAccessLog.entries()) {
+        for (const [word, perSession] of this.wordAccessLog.entries()) {
             if (!this.wordGraph.points.has(word)) continue;
             if (!this.vocabManager.word2idx.has(word)) continue;
             if (protectedWords.has(word)) continue;
-            stats.push({ word, count: recent.length });
+
+            // 统计最近会话窗口内的使用次数
+            let count = 0;
+            if (perSession instanceof Map) {
+                for (const [sid, c] of perSession.entries()) {
+                    if (recentSet.has(sid)) count += c || 0;
+                }
+            } else if (Array.isArray(perSession)) {
+                // 兼容旧格式（时间戳数组），视作一个遗留会话
+                count = perSession.length;
+            }
+            stats.push({ word, count });
         }
         if (stats.length === 0) return;
 
         stats.sort((a, b) => a.count - b.count);
 
-        // 限制每轮上限，避免快速抽干
-        const maxForgetRate = 0.001; // 改为每轮最多0.1%
+        // 每轮最多遗忘 0.1%（更保守）
+        const maxForgetRate = 0.001;
         const n = Math.max(1, Math.floor(stats.length * maxForgetRate));
+        const toForget = stats.slice(0, n).filter(s => s.count === 0).map(s => s.word);
+
+        if (toForget.length === 0) return;
 
-        const toForget = stats.slice(0, n).map(s => s.word);
         for (const word of toForget) {
             this.wordGraph.points.delete(word);
             this.vocabManager.vocab = this.vocabManager.vocab.filter(w => w !== word);
             this.vocabManager.updateMappings();
             this.wordAccessLog.delete(word);
-            console.log(`[FORGET] 淘汰词语点: ${word}`);
+            console.log(`[FORGET] 淘汰词语点(无最近会话使用): ${word}`);
 
             // 同步清理所有模因节点的词表
             for (const [memeID, words] of this.kvm.memory.entries()) {
@@ -1010,9 +2291,6 @@ class Runtime {
                 }
             }
         }
-
-        // 不在这里调用 runMainLoop，避免循环内触发再次遗忘
-        // this.runMainLoop();
     }
     // 修改 initWordGraph 方法
     initWordGraph() {
@@ -1080,19 +2358,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 });
                     }
                 }
             }
@@ -1147,7 +2421,11 @@ 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 (triggerResearch && this.researcher) {
+            try { this.researcher.scheduleFromWords(wordsArr); } catch (_) { }
+        }
         // 批量处理新词添加
         if (addNewWords) {
             // 一次性检查哪些词不在词表中
@@ -1233,7 +2511,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();
@@ -1243,9 +2521,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 {
             // 创建新模因
@@ -1256,9 +2534,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}`);
         }
     }
     // 新增批量添加边的辅助方法
@@ -1542,7 +2820,7 @@ class Runtime {
             this.kvm.memory.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 {
@@ -1559,7 +2837,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})`);
                 }
             }
         }
@@ -1590,14 +2868,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.memory.delete(memeID);
-         //   console.log(`[SPLIT-FORCE] 删除原模因: ${memeID}`);
+            //   console.log(`[SPLIT-FORCE] 删除原模因: ${memeID}`);
             return;
         }
 
@@ -1645,12 +2923,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.memory.delete(memeID);
-        //    console.log(`[SPLIT] 删除原模因: ${memeID}`);
+            //    console.log(`[SPLIT] 删除原模因: ${memeID}`);
         }
     }
 }
@@ -1670,6 +2948,7 @@ class AssociationLayer {
     constructor(runtime) {
         this.runtime = runtime;
         this.patterns = []; // 存储发现的模因边关系模式
+        this._prevClone = null; // 差量克隆基线
     }
 
     // 识别模因层的边关系模式
@@ -1726,83 +3005,33 @@ class AssociationLayer {
     // ...前面的代码...
 
     // 创建系统副本
+    // 创建系统副本（差量克隆）
     async cloneSystem() {
-        console.log('[CLONE] 创建系统副本');
-        const clone = new Runtime();
-        clone.registerClone();
-
+        console.log('[CLONE] 差量克隆系统(递归分区哈希)');
         try {
-            // 1. 确保Spider实例共享
-            clone.spider = this.runtime.spider;
-
-            // 2. 复制词表（确保顺序一致）
-            clone.vocabManager.vocab = [...this.runtime.vocabManager.vocab];
-            clone.vocabManager.updateMappings();
-
-            // 3. 复制词语网络
-            console.log('[CLONE] 开始复制词语网络...');
+            const clone = await deltaCloneRuntime(this._prevClone, this.runtime);
+            clone.registerClone();
+            this._prevClone = clone;
+            return clone;
+        } catch (err) {
+            console.warn('[CLONE] 差量克隆失败，回退全量:', err.message);
+            const fallback = new Runtime();
+            fallback.registerClone();
+            fallback.spider = this.runtime.spider;
+            fallback.vocabManager.vocab = [...this.runtime.vocabManager.vocab];
+            fallback.vocabManager.updateMappings();
             for (const [key, value] of this.runtime.wordGraph.points.entries()) {
-                clone.wordGraph.addPoint(key, Array.isArray(value.connect) ?
-                    value.connect.map(conn => [...conn]) : []);
+                fallback.wordGraph.addPoint(key, Array.isArray(value.connect) ? value.connect.map(conn => [...conn]) : []);
             }
-
-            // 4. 复制模因网络
-            console.log('[CLONE] 开始复制模因网络...');
             for (const [key, value] of this.runtime.graph.points.entries()) {
-                clone.graph.addPoint(key, Array.isArray(value.connect) ?
-                    value.connect.map(conn => [...conn]) : []);
+                fallback.graph.addPoint(key, Array.isArray(value.connect) ? value.connect.map(conn => [...conn]) : []);
             }
-
-            // 5. 复制KVM - 确保一致性和类型
-            console.log('[CLONE] 开始复制KVM...');
-            let nonEmptyCount = 0;
-            let totalWordCount = 0;
-
             for (const [key, value] of this.runtime.kvm.memory.entries()) {
-                // 严格规范化所有词汇
-                if (Array.isArray(value)) {
-                    // 确保数组中每个元素都是字符串且归一化
-                    const normalizedWords = value.map(word =>
-                        typeof word === 'string' ? word.toLowerCase().trim() : String(word)
-                    );
-
-                    // 应用词形归一化
-                    const lemmatizedWords = clone.spider.lemmatizeWords(normalizedWords);
-                    clone.kvm.set(key, lemmatizedWords);
-
-                    if (lemmatizedWords.length > 0) {
-                        nonEmptyCount++;
-                        totalWordCount += lemmatizedWords.length;
-                    }
-                } else if (value != null) {
-                    // 非数组值转换为单元素数组
-                    const singleWord = String(value).toLowerCase().trim();
-                    const lemmatizedWord = clone.spider.lemmatize(singleWord);
-                    clone.kvm.set(key, [lemmatizedWord]);
-
-                    nonEmptyCount++;
-                    totalWordCount++;
-                } else {
-                    // null或undefined情况，设为空数组
-                    clone.kvm.set(key, []);
-                }
+                fallback.kvm.set(key, Array.isArray(value) ? [...value] : (value == null ? [] : [String(value)]));
             }
-
-            console.log(`[CLONE] KVM复制完成: ${nonEmptyCount}个非空模因，${totalWordCount}个词语`);
-
-            // 6. 复制其他配置和参数
-            console.log('[CLONE] 开始复制词表和其他属性...');
-            clone.MAX_MEME_WORDS = this.runtime.MAX_MEME_WORDS;
-            clone.MIN_OVERLAP = this.runtime.MIN_OVERLAP;
-            clone.config = { ...this.runtime.config };
-
-            console.log('[CLONE] 系统副本创建完成');
-            return clone;
-        } catch (error) {
-            console.error('[CLONE ERROR]', error);
-            return clone;
+            return fallback;
         }
-    }    // 将模式应用到系统副本
+    }
 
     applyPatternsToClone(systemClone) {
         console.log('[CLONE] 应用关系模式到副本');
@@ -1859,7 +3088,7 @@ class AssociationLayer {
                         meme.connect[connIdx][0] = newWeight;
                         meme.connect[connIdx][2] = direction;
 
-      //                  console.log(`[CLONE] 修改边权重: ${meme.pointID}->${meme.connect[connIdx][1]}, ${oldWeight}->${newWeight.toFixed(2)}, 保留方向: ${direction}`);
+                        //                  console.log(`[CLONE] 修改边权重: ${meme.pointID}->${meme.connect[connIdx][1]}, ${oldWeight}->${newWeight.toFixed(2)}, 保留方向: ${direction}`);
                         modified++;
                     }
                 }
@@ -2571,10 +3800,10 @@ class controller {
     }
     // 处理用户输入
     async handleInput(text) {
+        const sid = this.runtime.session.ensureActive();
+        this.runtime.session.incMessage(sid);
         const words = text.toLowerCase().split(' ').filter(w => w.length > 0);
-        this.runtime.processInput(words, { addNewWords: false });
-        // 用模因网络参与推理
-        //console.log('[DEBUG] 当前所有模因节点:', this.runtime.kvm.memory);
+        this.runtime.processInput(words, { addNewWords: false, triggerResearch: true });
         return await this.runtime.generateResponseWithMemes(words);
     }
     // 启动自主学习
@@ -2648,15 +3877,23 @@ let saveQueued = false;
 
 // 保存所有点、图、词表等到硬盘
 function saveAll(runtime) {
+    // 规范化 wordAccessLog 为 [word, [[sessionId, count], ...]]
+    const serializedWordAccess = Array.from(runtime.wordAccessLog.entries()).map(([w, per]) => {
+        if (per instanceof Map) return [w, Array.from(per.entries())];
+        if (Array.isArray(per)) return [w, [['legacy', per.length]]]; // 兼容旧格式
+        return [w, []];
+    });
+
     // 只更新内存缓存
     latestRuntimeData = {
         memes: runtime.graph.getAllPoints(),
         wordGraph: Array.from(runtime.wordGraph.points.values()),
         kvm: Array.from(runtime.kvm.memory.entries()),
         vocab: runtime.vocabManager.vocab,
-        wordAccessLog: Array.from(runtime.wordAccessLog ? runtime.wordAccessLog.entries() : [])
+        wordAccessLog: serializedWordAccess,
+        // 新增：会话信息持久化
+        sessions: runtime.session.export()
     };
-    // 标记有保存请求
     saveQueued = true;
 }
 // 定时真正写入硬盘，只保存最新的
@@ -2668,6 +3905,28 @@ setInterval(() => {
         saveQueued = false;
     }
 }, 10000); // 每10秒最多写盘一次
+setInterval(async () => {
+    try {
+        if (!global.__crawler || !global.ctrlA) return;
+        const mix = global.ctrlA.runtime.config.spiderMix || { onlineWeight: 0.5, offlineWeight: 0.5 };
+        // 以 1 - onlineWeight 的概率跳过本轮（控制强度）
+        if (Math.random() > (mix.onlineWeight || 0.5)) return;
+
+        const docs = global.__crawler.loadRecentDocs(12);
+        if (!docs.length) return;
+        let fed = 0;
+        for (const d of docs) {
+            fed += await global.ctrlA.runtime.ingestTextDocument(d.text, { addNewWords: true, minLen: 6 });
+        }
+        if (fed > 0) {
+            console.log(`[INGEST] 在线文档本轮投喂 ${fed} 段 (mix=${mix.onlineWeight.toFixed(2)})`);
+            global.ctrlA.runtime.updateAttentionLinks();
+        }
+    } catch (e) {
+        console.warn('[INGEST] 失败:', e.message);
+    }
+}, 20_000);
+// 从硬盘恢复
 // 从硬盘恢复
 function loadAll(runtime) {
     if (!fs.existsSync(SAVE_PATH)) return;
@@ -2678,19 +3937,34 @@ function loadAll(runtime) {
             runtime.wordGraph.addPoint(point.pointID, point.connect);
         }
     }
-    // 3. 修改 loadAll 中的数据恢复
     if (data.kvm) {
         for (const [k, v] of data.kvm) {
             runtime.kvm.set(k, Array.isArray(v) ? v : [String(v)]);
-            // 确保一定是数组
         }
     }
     if (data.vocab) {
         runtime.vocabManager.vocab = data.vocab;
         runtime.vocabManager.updateMappings();
     }
+    // 恢复会话
+    if (data.sessions) {
+        runtime.session.import(data.sessions);
+    }
+    // 恢复词访问日志（新格式 Map<word, Map<sessionId, count>>）
     if (data.wordAccessLog && runtime.wordAccessLog) {
-        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])) {
+                // 新格式：[[sid, count], ...]
+                restored.set(word, new Map(per));
+            } else if (Array.isArray(per)) {
+                // 旧格式的 timestamps 数组 -> 合并为 legacy 会话
+                restored.set(word, new Map([['legacy', per.length]]));
+            } else {
+                restored.set(word, new Map());
+            }
+        }
+        runtime.wordAccessLog = restored;
     }
     console.log(`[LOAD] 系统状态已从 ${SAVE_PATH} 恢复`);
 }
@@ -2698,138 +3972,16 @@ function loadAll(runtime) {
 
 
 function scheduleCrossLearning() {
-    const cycle = 1800 * 1000;      // 每轮周期（毫秒）
-    const learnTime = 200 * 1000;   // 每轮学习后等待时间
-
-    // A -> B
-    registerInterval(() => {
-        if (global.ctrlA.isLearning || global.ctrlB.isLearning || global.ctrlC.isLearning || isShuttingDown) return;
-        console.log('[CROSS] A开始学习');
-        global.ctrlA.startSelfLearning(3).then(() => {
-            setTimeout(async () => {
-                console.log('[CROSS] A将成果传递给B');
-                const associationLayer = new AssociationLayer(global.ctrlA.runtime);
-
-                // 归一化一致性测试
-                const testWord = "testing";
-                const normalizedWord = global.ctrlA.runtime.spider.lemmatize(testWord);
-                console.log(`[CROSS-CHECK] 词归一化测试: "${testWord}" -> "${normalizedWord}"`);
-                //const associationLayer = new AssociationLayer(global.ctrlA.runtime);
-                // 这里要加上
-                associationLayer.patterns = associationLayer.identifyPatterns();
-                // 克隆
-                const systemClone = await associationLayer.cloneSystem();
-                systemClone.spider = global.ctrlA.runtime.spider;
-                associationLayer.applyPatternsToClone(systemClone);
-
-                verifySystemConsistency(global.ctrlA.runtime, systemClone);
-
-                // 预热克隆系统
-                console.log('[CROSS] 预热克隆系统...');
-                const sampleWords = Array.from(
-                    new Set([...systemClone.vocabManager.vocab].slice(4, 20))
-                ).filter(w => w.length > 1);
-                await systemClone.processInput(sampleWords, { addNewWords: false });
-
-                await systemClone.startSelfLearning(3);
-                global.ctrlB.updateRuntime(systemClone);
-
-                verifySystemConsistency(global.ctrlA.runtime, global.ctrlB.runtime);
-
-                console.log('[CROSS] 已将A的系统更新到B');
-                testCloneMatching(global.ctrlB.runtime);
-            }, learnTime);
-        });
-    }, cycle);
-
-    // B -> C
-    registerInterval(() => {
-        if (global.ctrlA.isLearning || global.ctrlB.isLearning || global.ctrlC.isLearning || isShuttingDown) return;
-        global.ctrlB.startSelfLearning(3).then(() => {
-            setTimeout(async () => {
-                console.log('[CROSS] B将成果传递给C');
-                const associationLayer = new AssociationLayer(global.ctrlB.runtime);
-
-                const testWord = "testing";
-                const normalizedWord = global.ctrlB.runtime.spider.lemmatize(testWord);
-                console.log(`[CROSS-CHECK] 词归一化测试: "${testWord}" -> "${normalizedWord}"`);
-                // 这里要加上
-                associationLayer.patterns = associationLayer.identifyPatterns();
-                const systemClone = await associationLayer.cloneSystem();
-                systemClone.spider = global.ctrlB.runtime.spider;
-                associationLayer.applyPatternsToClone(systemClone);
-
-                verifySystemConsistency(global.ctrlB.runtime, systemClone);
-
-                console.log('[CROSS] 预热克隆系统...');
-                const sampleWords = Array.from(
-                    new Set([...systemClone.vocabManager.vocab].slice(4, 20))
-                ).filter(w => w.length > 1);
-                await systemClone.processInput(sampleWords, { addNewWords: false });
-
-                await systemClone.startSelfLearning(3);
-                global.ctrlC.updateRuntime(systemClone);
-
-                verifySystemConsistency(global.ctrlB.runtime, global.ctrlC.runtime);
-
-                console.log('[CROSS] 已将B的系统更新到C');
-                testCloneMatching(global.ctrlC.runtime);
-            }, learnTime);
-        });
-    }, cycle);
-
-    // C -> A
-    registerInterval(() => {
-        if (global.ctrlA.isLearning || global.ctrlB.isLearning || global.ctrlC.isLearning || isShuttingDown) return;
-        global.ctrlC.startSelfLearning(3).then(() => {
-            setTimeout(async () => {
-                console.log('[CROSS] C将成果传递给A');
-                const associationLayer = new AssociationLayer(global.ctrlC.runtime);
-
-                const testWord = "testing";
-                const normalizedWord = global.ctrlC.runtime.spider.lemmatize(testWord);
-                console.log(`[CROSS-CHECK] 词归一化测试: "${testWord}" -> "${normalizedWord}"`);
-                // 这里要加上
-                associationLayer.patterns = associationLayer.identifyPatterns();
-                const systemClone = await associationLayer.cloneSystem();
-                systemClone.spider = global.ctrlC.runtime.spider;
-                associationLayer.applyPatternsToClone(systemClone);
-
-                verifySystemConsistency(global.ctrlC.runtime, systemClone);
-
-                console.log('[CROSS] 预热克隆系统...');
-                const sampleWords = Array.from(
-                    new Set([...systemClone.vocabManager.vocab].slice(4, 20))
-                ).filter(w => w.length > 1);
-                await systemClone.processInput(sampleWords, { addNewWords: false });
-
-                await systemClone.startSelfLearning(3);
-                global.ctrlA.updateRuntime(systemClone);
-
-                verifySystemConsistency(global.ctrlC.runtime, global.ctrlA.runtime);
-
-                console.log('[CROSS] 已将C的系统更新到A');
-                testCloneMatching(global.ctrlA.runtime);
-            }, learnTime);
-        });
-        console.log('Publishing runtime state to Redis...');
-        if (!RuntimeMessage) return; // protobuf未加载完成
-        if (!redisClient || !redisClient.isOpen) {
-            console.warn('[REDIS] 客户端未连接，跳过发布');
-            return;
-        }
-        if (!RuntimeMessage) return;
-        if (global.ctrlA.runtime.isLearning || global.ctrlA.runtime.isMainLoopRunning) return;
-        const plainObj = runtimeToPlain(global.ctrlA.runtime);
-        const errMsg = RuntimeMessage.verify(plainObj);
-        if (errMsg) throw Error(errMsg);
-        const message = RuntimeMessage.create(plainObj);
-        const buffer = RuntimeMessage.encode(message).finish();
-        redisClient.publish(`AI-model-${__dirname}`, buffer);
-        console.log('已发布运行时状态到Redis');
-    }, cycle);
+    const rot = new RotationManager(global.ctrlA, global.ctrlB, global.ctrlC, {
+        cycleMs: 15 * 60 * 1000, // 可根据需要调整
+        cooldownMs: 60 * 1000,
+        learnIters: 3,
+        minImprove: 0.005
+    });
+    rot.start();
 }
 
+
 // 新增：测试克隆系统的词汇匹配能力
 function testCloneMatching(runtime) {
     // 从词表中随机选取10个词
@@ -2968,7 +4120,7 @@ function optimizeMemory() {
     }
 }
 async function main() {
-      console.log('Starting AI system...');
+    console.log('Starting AI system...');
     redisClient = redis.createClient();
     // 创建三个全局控制器副本
     const ctrlA = new controller();
@@ -2983,11 +4135,38 @@ async function main() {
     loadAll(ctrlA.runtime);
     loadAll(ctrlB.runtime);
     loadAll(ctrlC.runtime);
-
+    const crawler = new CrawlerManager({
+        concurrency: 5,
+        perHostDelayMs: 2000,
+        requestTimeoutMs: 12000,
+        allowLang: ['en', 'zh'],
+        seedsFile: path.join(__dirname, 'robots', 'seeds.txt'),
+        proxiesFile: path.join(__dirname, 'crawler', 'proxies.txt')
+    });
+    global.__crawler = crawler;
+    crawler.start();
+    setInterval(async () => {
+        try {
+            const docs = crawler.loadRecentDocs(12);
+            if (!docs.length) return;
+            let fed = 0;
+            for (const d of docs) {
+                fed += await ctrlA.runtime.ingestTextDocument(d.text, { addNewWords: true, minLen: 6 });
+            }
+            if (fed > 0) {
+                console.log(`[INGEST] 在线文档本轮投喂 ${fed} 段`);
+                // 适当刷新注意力连接
+                ctrlA.runtime.updateAttentionLinks();
+            }
+        } catch (e) {
+            console.warn('[INGEST] 失败:', e.message);
+        }
+    }, 20_000); // 每20秒消费一批
     // 用A副本初始化语料和模因
     console.time('articleProcessing');
     const articles = ctrlA.runtime.buildVocabFromSpider();
     console.log(`Spider: 加载文章数: ${articles.length}`);
+    // 周期性消费在线文档 -> 投喂到 ctrlA.runtime
 
     // 修复：在首次使用前定义 lemmaCsvPath
     const BATCH_SIZE = 20;
@@ -3040,13 +4219,171 @@ async function main() {
         //每12分钟尝试启动memebarrier
         ctrlA.runtime.memeBarrier.start();
     }, 1000 * 60 * 12);
+
+
+    // 可选：启动（默认不开启，避免未配置API Key）
+    if (String(process.env.ADV_AUTOSTART || '').toLowerCase() === 'true') {
+        adv.start();
+    }
+// 新增：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 });
+    }
+});
+    // API
+// 初始化对抗学习调度器时传递 promptMode/targetWeights 可选参数
+// ...existing code...
+const adv = new AdversaryScheduler(ctrlA.runtime, {
+    providerSpec: process.env.ADV_MODEL || 'ollama:llama3.1:405b',
+    judgeMode: process.env.ADV_JUDGE || 'llm',
+    intervalMs: Number(process.env.ADV_INTERVAL || 60_000),
+    batchSize: Number(process.env.ADV_BATCH || 3),
+    promptMode: process.env.ADV_PROMPT_MODE || 'mixed',
+    targetWeights: {
+        decayK: Number(process.env.TUNE_W_DECAYK || 1.0),
+        maxLen: Number(process.env.TUNE_W_MAXLEN || 0.7),
+        onlineWeight: Number(process.env.TUNE_W_ONLINE || 0.8),
+        edgeWeight: Number(process.env.TUNE_W_EDGE || 0.4),
+        perQuery: Number(process.env.TUNE_W_PERQ || 0.5),
+        maxCrawl: Number(process.env.TUNE_W_MAXC || 0.5),
+    }
+});
+// ...existing code...
+    global.__adversary = adv;
+
+// 对抗学习控制 API 增补 promptMode / targets
+app.post('/api/adversary/start', (req, res) => {
+    try {
+        const { provider, judgeMode, intervalMs, batchSize, promptMode, targetWeights } = req.body || {};
+        if (provider) {
+            const neo = new AdversaryScheduler(global.ctrlA.runtime, {
+                providerSpec: provider,
+                judgeMode: judgeMode || adv.opts.judgeMode,
+                intervalMs: Number(intervalMs || adv.opts.intervalMs),
+                batchSize: Number(batchSize || adv.opts.batchSize),
+                promptMode: promptMode || adv.opts.promptMode,
+                targetWeights: targetWeights || adv.opts.targetWeights
+            });
+            global.__adversary?.stop?.();
+            global.__adversary = neo;
+            global.__adversary.start();
+        } else {
+            if (promptMode) adv.setPromptMode(promptMode);
+            if (targetWeights) adv.setTargets(targetWeights);
+            adv.start();
+        }
+        res.json({ ok: true, status: global.__adversary.getStatus() });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+    app.post('/api/adversary/stop', (req, res) => {
+        try { global.__adversary?.stop?.(); res.json({ ok: true }); }
+        catch (e) { res.status(500).json({ ok: false, error: e.message }); }
+    });
+
+    app.get('/api/adversary/status', (req, res) => {
+        try { res.json({ ok: true, status: global.__adversary?.getStatus?.() || { running: false } }); }
+        catch (e) { res.status(500).json({ ok: false, error: e.message }); }
+    });
+
+    // 触发一次性对抗评估（可指定 prompts 数组）
+    app.post('/api/adversary/once', async (req, res) => {
+        try {
+            const prompts = Array.isArray(req.body?.prompts) ? req.body.prompts.slice(0, 5) : null;
+            const report = await global.__adversary.evaluateOnce(prompts);
+            res.json({ ok: true, report });
+        } catch (e) {
+            res.status(500).json({ ok: false, error: e.message });
+        }
+    });
+    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 });
+        }
+    });
     // API路由 - 只做学习，不返回结果
     app.post('/api/chat', async (req, res) => {
         try {
-            const { message } = req.body;
-            ctrlA.runtime.processInput(message.toLowerCase().split(' ').filter(w => w.length > 0));
-            ctrlA.runtime.updateAttentionLinks();
-            res.status(204).end(); // 不返回内容
+            const { message, sessionId } = req.body || {};
+            const headerSid = req.headers['x-session-id'];
+            const sid = sessionId || headerSid || global.ctrlA.runtime.session.ensureActive();
+
+            global.ctrlA.runtime.session.useSession(sid);
+            global.ctrlA.runtime.session.incMessage(sid);
+
+            const words = String(message || '').toLowerCase().split(/\s+/).filter(w => w.length > 0);
+            // 开启按需检索
+            global.ctrlA.runtime.processInput(words, { triggerResearch: true });
+            global.ctrlA.runtime.updateAttentionLinks();
+
+            res.set('X-Session-Id', sid);
+            res.status(204).end();
         } catch (error) {
             res.status(500).json({ error: error.message });
             console.error('Error in /api/chat:', error);
@@ -3107,7 +4444,20 @@ async function main() {
             res.status(500).json({ success: false, error: error.message });
         }
     });
-
+    app.post('/api/crawler/start', (req, res) => {
+        try { global.__crawler?.start(); res.json({ ok: true }); } catch (e) { res.status(500).json({ ok: false, error: e.message }); }
+    });
+    app.post('/api/crawler/stop', (req, res) => {
+        try { global.__crawler?.stop(); res.json({ ok: true }); } catch (e) { res.status(500).json({ ok: false, error: e.message }); }
+    });
+    app.post('/api/crawler/seed', (req, res) => {
+        const { urls } = req.body || {};
+        const n = global.__crawler?.addSeeds(Array.isArray(urls) ? urls : []) || 0;
+        res.json({ ok: true, added: n });
+    });
+    app.get('/api/crawler/status', (req, res) => {
+        res.json({ ok: true, stats: global.__crawler?.stats() || {} });
+    });
 
     // 模型默认参数
     const modelDefaults = {
@@ -3160,6 +4510,49 @@ async function main() {
         console.log(`\nAI system running on port ${global.config.masterPortOfMain}`);
         console.log(`API available at http://localhost:${global.config.masterPortOfMain}/api/`);
     });
+    app.post('/api/search-crawl', async (req, res) => {
+        try {
+            const { prompt, vertical, perQuery, maxEnqueue, crawl, maxCrawl, ingest = true, minLen = 6 } = req.body || {};
+            if (!prompt || String(prompt).trim().length < 2) {
+                return res.status(400).json({ ok: false, error: 'prompt 不能为空' });
+            }
+            if (!global.__crawler) {
+                return res.status(500).json({ ok: false, error: 'crawler 未初始化' });
+            }
+            const report = await global.__crawler.directedSearch(String(prompt), {
+                vertical: vertical || 'general',
+                perQuery: perQuery || 8,
+                maxEnqueue: maxEnqueue || 30,
+                crawl: crawl !== false,
+                maxCrawl: maxCrawl || 12
+            });
+
+            let fed = 0;
+            if (ingest !== false) {
+                const docs = global.__crawler.loadRecentDocs(24);
+                for (const d of docs) {
+                    fed += await global.ctrlA.runtime.ingestTextDocument(d.text, { addNewWords: true, minLen });
+                }
+                if (fed > 0) global.ctrlA.runtime.updateAttentionLinks();
+            }
+
+            res.json({ ok: true, report, ingestedSegments: fed });
+        } catch (e) {
+            res.status(500).json({ ok: false, error: e.message });
+        }
+    });
+
+    // 仅添加待抓取URL（不立即抓）
+    app.post('/api/crawler/query', async (req, res) => {
+        try {
+            const { prompt, vertical } = req.body || {};
+            if (!prompt) return res.status(400).json({ ok: false, error: 'prompt 不能为空' });
+            const report = await global.__crawler.directedSearch(String(prompt), { vertical: vertical || 'general', crawl: false });
+            res.json({ ok: true, report });
+        } catch (e) {
+            res.status(500).json({ ok: false, error: e.message });
+        }
+    });
     // 启动Redis客户端
     redisClient.on('error', (err) => {
         console.error('Redis error:', err);
@@ -3208,16 +4601,7 @@ function applyModelParams(runtime) {
 }
 // 如果直接运行此文件，启动主函数
 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)
 }