079project 6.0.0 → 8.0.0

package/main.cjs

@@ -24,6 +24,11 @@ const natural = safeRequire('natural');
 const csvParse = safeRequire('csv-parse/sync');
 const umap = safeRequire('umap-js');
 const axios = safeRequire('axios');
+const cheerio = safeRequire('cheerio');
+const pdfParse = safeRequire('pdf-parse');
+// 安全引用 ml-matrix，兼容不同导出结构
+const MatrixLib = safeRequire('ml-matrix');
+const Matrix = MatrixLib?.Matrix ?? MatrixLib ?? null;
 
 const STOP_WORDS = natural?.stopwords ?? [];
 const DEFAULT_CHANNEL = process.env.AI_REDIS_CHANNEL || 'AI-model-workspace';
@@ -55,10 +60,16 @@ const CONFIG = (() => {
         return !(normalized === '0' || normalized === 'false' || normalized === 'off' || normalized === 'no');
     };
     const robotsLimitRaw = args['robots-limit'] || process.env.AI_ROBOTS_LIMIT || 200;
+    const aiCountRaw = args['ai-count'] || process.env.AI_COUNT || process.env.AI_NUM || 7;
+    const groupCountRaw = args['group-count'] || process.env.AI_GROUP_COUNT || process.env.GROUP_COUNT || 3;
     return {
         baseDir: path.resolve(args['base-dir'] || process.env.AI_BASE_DIR || path.join(__dirname, 'runtime_store')),
+        gatewayHost: String(args['gateway-host'] || process.env.AI_GATEWAY_HOST || '127.0.0.1'),
         portGateway: Number(args.port || process.env.CONTROLLER_PORT || 5080),
         portStudy: Number(args['study-port'] || process.env.AI_STUDY_PORT || 5081),
+        aiCount: Math.max(3, Number(aiCountRaw) || 7),
+        groupCount: Math.max(1, Number(groupCountRaw) || 3),
+        groupSize: 7,
         redisUrl: process.env.REDIS_URL || args['redis-url'] || 'redis://127.0.0.1:6379',
         redisChannel: args.channel || DEFAULT_CHANNEL,
         snapshotDir: args['snapshot-dir'] || path.join(__dirname, 'snapshots'),
@@ -70,7 +81,13 @@ const CONFIG = (() => {
         robotsDir: path.resolve(args['robots-dir'] || process.env.AI_ROBOTS_DIR || path.join(__dirname, 'robots')),
         lemmaCsv: path.resolve(args['lemma-csv'] || process.env.AI_LEMMA_CSV || path.join(__dirname, 'lemma.csv')),
         robotsWarmupLimit: Math.max(0, Number(robotsLimitRaw) || 0),
-        robotsAutoload: boolFrom(args['robots-autoload'] ?? process.env.AI_ROBOTS_AUTOLOAD, true)
+        robotsAutoload: boolFrom(args['robots-autoload'] ?? process.env.AI_ROBOTS_AUTOLOAD, true),
+        // Feature toggles via CLI/env
+        disableBarrier: boolFrom(args['disable-memebarrier'] ?? process.env.AI_DISABLE_MEMEBARRIER, false) === true,
+        disableRL: boolFrom(args['disable-rl'] ?? process.env.AI_DISABLE_RL, false) === true,
+        disableADV: boolFrom(args['disable-adv'] ?? process.env.AI_DISABLE_ADV, false) === true,
+        disableLearning: boolFrom(args['disable-learning'] ?? process.env.AI_DISABLE_LEARNING, false) === true,
+        exportDir: path.resolve(args['export-dir'] || process.env.AI_EXPORT_DIR || path.join(__dirname, 'runtime_store'))
     };
 })();
 
@@ -232,6 +249,56 @@ class LmdbStore {
     }
 }
 
+class NamespacedStore {
+    constructor(store, namespace) {
+        this.store = store;
+        this.ns = String(namespace || '').trim();
+        if (!this.ns) {
+            throw new Error('NamespacedStore requires a namespace');
+        }
+        this.prefix = `ns:${this.ns}:`;
+    }
+
+    _k(key) {
+        return `${this.prefix}${String(key)}`;
+    }
+
+    get(key) {
+        return this.store.get(this._k(key));
+    }
+
+    put(key, value) {
+        return this.store.put(this._k(key), value);
+    }
+
+    delete(key) {
+        return this.store.delete(this._k(key));
+    }
+
+    entries(prefix = '') {
+        const list = this.store.entries(this._k(prefix));
+        const out = [];
+        for (const [key, value] of list) {
+            const k = String(key);
+            if (!k.startsWith(this.prefix)) {
+                continue;
+            }
+            out.push([k.slice(this.prefix.length), value]);
+        }
+        return out;
+    }
+
+    flush() {
+        if (typeof this.store.flush === 'function') {
+            this.store.flush();
+        }
+    }
+
+    close() {
+        // underlying store lifecycle is managed centrally
+    }
+}
+
 process.on('exit', () => {
     // In this single-file mode stores are closed elsewhere.
 });
@@ -587,6 +654,11 @@ class MemeGraph {
         }
     }
 
+    // 返回当前图中所有模因节点的ID列表，供扫描器等模块使用
+    getAllPoints() {
+        return Array.from(this.meta.keys());
+    }
+
     _persistNode(memeId) {
         const neighbors = this.nodes.get(memeId) || new Map();
         const payload = {
@@ -753,9 +825,16 @@ class TensorEngine {
             const start = rowPtr[row];
             const end = rowPtr[row + 1];
             for (let idx = start; idx < end; idx++) {
-                acc += values[idx] * x[colIdx[idx]];
+                const w = values[idx];
+                const j = colIdx[idx];
+                const xv = (j >= 0 && j < x.length) ? x[j] : 0;
+                if (!Number.isFinite(w) || !Number.isFinite(xv)) {
+                    // 忽略非有限值，避免传播 NaN
+                    continue;
+                }
+                acc += w * xv;
             }
-            result[row] = acc;
+            result[row] = Number.isFinite(acc) ? acc : 0;
         }
         return result;
     }
@@ -797,11 +876,28 @@ class TensorEngine {
     iteratePropagation(csr, seeds, steps, actFn, decayK, damp = 0.02) {
         let state = Float32Array.from(seeds);
         const next = new Float32Array(seeds.length);
+        const safeAct = (x) => {
+            let y;
+            try {
+                y = actFn(x);
+            } catch (_) {
+                y = 0;
+            }
+            return Number.isFinite(y) ? y : 0;
+        };
         for (let s = 0; s < steps; s++) {
             this.spmm(csr, state, next);
             for (let i = 0; i < next.length; i++) {
-                const raw = state[i] + next[i] - decayK * state[i] * damp;
-                state[i] = actFn(raw);
+                const si = Number.isFinite(state[i]) ? state[i] : 0;
+                const ni = Number.isFinite(next[i]) ? next[i] : 0;
+                const raw = si + ni - (Number.isFinite(decayK) ? decayK : 0) * si * (Number.isFinite(damp) ? damp : 0.02);
+                state[i] = safeAct(raw);
+            }
+        }
+        // 最终保障结果为有限值
+        for (let i = 0; i < state.length; i++) {
+            if (!Number.isFinite(state[i])) {
+                state[i] = 0;
             }
         }
         return state;
@@ -1027,6 +1123,7 @@ class OnlineResearcher {
         this.cooldownMs = cooldownMs;
         this.cacheSize = cacheSize;
         this.cache = new Map();
+        this.enabled = true;
     }
 
     _normalize(words) {
@@ -1062,7 +1159,39 @@ class OnlineResearcher {
     }
 
     async lookup(input, options = {}) {
-        const words = Array.isArray(input) ? input : tokenize(String(input || ''));
+        if (this.enabled === false || options.disableRemote === true) {
+            return this._fallback(Array.isArray(input) ? input : tokenize(String(input || '')));
+        }
+        // 如果输入里包含 URL（或显式要求 crawl），优先走站内递归抓取
+        const rawText = Array.isArray(input) ? input.join(' ') : String(input || '');
+        const crawlReq = options?.crawl || null;
+        const urlFromInput = extractFirstUrl(rawText);
+        const shouldCrawl = options?.mode === 'crawl' || Boolean(crawlReq?.startUrl) || Boolean(urlFromInput);
+        if (shouldCrawl) {
+            const startUrl = String(crawlReq?.startUrl || urlFromInput || '').trim();
+            if (!startUrl) {
+                return { ok: false, source: 'crawl', reason: 'startUrl-required' };
+            }
+            const crawlOptions = {
+                maxPages: clampInt(crawlReq?.maxPages, 1, 500, 60),
+                maxDepth: clampInt(crawlReq?.maxDepth, 0, 10, 3),
+                includePdf: crawlReq?.includePdf !== false,
+                sameSite: crawlReq?.sameSite !== false,
+                timeoutMs: clampInt(crawlReq?.timeoutMs, 1000, 60000, 12000),
+                maxBytesPerPage: clampInt(crawlReq?.maxBytesPerPage, 8 * 1024, 10 * 1024 * 1024, 2 * 1024 * 1024),
+                maxPdfBytes: clampInt(crawlReq?.maxPdfBytes, 64 * 1024, 40 * 1024 * 1024, 20 * 1024 * 1024),
+                userAgent: typeof crawlReq?.userAgent === 'string' && crawlReq.userAgent.trim() ? crawlReq.userAgent.trim() : '079ProjectCrawler/1.0'
+            };
+            const crawler = new SiteCrawler({ axios, cheerio, pdfParse });
+            const result = await crawler.crawl(startUrl, crawlOptions);
+            if (!options?.forceRemote) {
+                const key = this._normalize(tokenize(`crawl ${startUrl}`));
+                this._remember(key, result);
+            }
+            return result;
+        }
+
+        const words = Array.isArray(input) ? input : tokenize(rawText);
         if (words.length === 0) {
             return { ok: false, source: 'local', reason: 'empty-query' };
         }
@@ -1133,6 +1262,240 @@ class OnlineResearcher {
     }
 }
 
+const clampInt = (value, min, max, fallback) => {
+    const n = Number(value);
+    if (!Number.isFinite(n)) return fallback;
+    return Math.max(min, Math.min(max, Math.trunc(n)));
+};
+
+const extractFirstUrl = (text) => {
+    const s = String(text || '').trim();
+    if (!s) return null;
+    // 优先匹配 http(s)://
+    const m = s.match(/https?:\/\/[\w\-._~:/?#[\]@!$&'()*+,;=%]+/i);
+    if (m && m[0]) return m[0];
+    // 兼容裸域名：www.example.com/path
+    const m2 = s.match(/\b(?:www\.)[a-z0-9\-]+(?:\.[a-z0-9\-]+)+(?:\/[\w\-._~:/?#[\]@!$&'()*+,;=%]*)?/i);
+    if (m2 && m2[0]) return `https://${m2[0]}`;
+    return null;
+};
+
+class SiteCrawler {
+    constructor({ axios, cheerio, pdfParse } = {}) {
+        this.axios = axios;
+        this.cheerio = cheerio;
+        this.pdfParse = pdfParse;
+    }
+
+    _normalizeUrl(url) {
+        try {
+            const u = new URL(url);
+            u.hash = '';
+            // 轻度去重：丢弃常见追踪参数
+            for (const key of Array.from(u.searchParams.keys())) {
+                if (/^(utm_|fbclid$|gclid$)/i.test(key)) u.searchParams.delete(key);
+            }
+            return u.toString();
+        } catch {
+            return null;
+        }
+    }
+
+    _sameSite(baseUrl, targetUrl) {
+        try {
+            const base = new URL(baseUrl);
+            const t = new URL(targetUrl);
+            const baseHost = base.hostname.replace(/^www\./i, '');
+            const tHost = t.hostname.replace(/^www\./i, '');
+            return base.protocol === t.protocol && baseHost === tHost;
+        } catch {
+            return false;
+        }
+    }
+
+    _extractLinksHtml(html, baseUrl) {
+        const out = [];
+        if (!html) return out;
+        const base = String(baseUrl || '');
+        if (this.cheerio) {
+            try {
+                const $ = this.cheerio.load(html);
+                const push = (href) => {
+                    if (!href) return;
+                    const h = String(href).trim();
+                    if (!h || h.startsWith('javascript:') || h.startsWith('mailto:') || h.startsWith('#')) return;
+                    try {
+                        const u = new URL(h, base);
+                        out.push(u.toString());
+                    } catch {}
+                };
+                $('a[href]').each((_, el) => push($(el).attr('href')));
+                $('link[href]').each((_, el) => push($(el).attr('href')));
+                $('iframe[src]').each((_, el) => push($(el).attr('src')));
+                return out;
+            } catch {
+                // fallthrough
+            }
+        }
+        // 简单正则 fallback
+        const re = /\b(?:href|src)\s*=\s*['"]([^'"#]+)['"]/gi;
+        let m;
+        while ((m = re.exec(html))) {
+            const href = m[1];
+            if (!href) continue;
+            if (/^(javascript:|mailto:)/i.test(href)) continue;
+            try {
+                const u = new URL(href, base);
+                out.push(u.toString());
+            } catch {}
+        }
+        return out;
+    }
+
+    _extractTextHtml(html) {
+        if (!html) return '';
+        if (this.cheerio) {
+            try {
+                const $ = this.cheerio.load(html);
+                $('script,noscript,style').remove();
+                const text = $('body').text() || $.root().text() || '';
+                return text.replace(/\s+/g, ' ').trim();
+            } catch {
+                // fallthrough
+            }
+        }
+        return String(html).replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    }
+
+    async _fetch(url, { timeoutMs, userAgent, responseType, maxBytes } = {}) {
+        if (!this.axios) {
+            throw new Error('axios-not-installed');
+        }
+        const resp = await this.axios.get(url, {
+            timeout: timeoutMs ?? 12000,
+            responseType: responseType || 'arraybuffer',
+            maxContentLength: maxBytes,
+            maxBodyLength: maxBytes,
+            headers: {
+                'User-Agent': userAgent || '079ProjectCrawler/1.0',
+                'Accept': 'text/html,application/xhtml+xml,application/pdf;q=0.9,*/*;q=0.8'
+            },
+            validateStatus: (s) => s >= 200 && s < 400
+        });
+        const ctype = String(resp.headers?.['content-type'] || '').toLowerCase();
+        const buf = Buffer.isBuffer(resp.data) ? resp.data : Buffer.from(resp.data);
+        return { status: resp.status, contentType: ctype, bytes: buf.length, data: buf };
+    }
+
+    async _parsePdf(buffer) {
+        if (!buffer || !Buffer.isBuffer(buffer)) return { text: '' };
+        if (!this.pdfParse) {
+            return { text: '', warning: 'pdf-parse-not-installed' };
+        }
+        const r = await this.pdfParse(buffer);
+        const text = String(r?.text || '').replace(/\s+/g, ' ').trim();
+        return { text, pages: r?.numpages };
+    }
+
+    async crawl(startUrl, options = {}) {
+        const normalizedStart = this._normalizeUrl(startUrl);
+        if (!normalizedStart) {
+            return { ok: false, source: 'crawl', reason: 'invalid-url' };
+        }
+        const {
+            maxPages = 60,
+            maxDepth = 3,
+            includePdf = true,
+            sameSite = true,
+            timeoutMs = 12000,
+            maxBytesPerPage = 2 * 1024 * 1024,
+            maxPdfBytes = 20 * 1024 * 1024,
+            userAgent = '079ProjectCrawler/1.0'
+        } = options;
+
+        const visited = new Set();
+        const queue = [{ url: normalizedStart, depth: 0 }];
+        const pages = [];
+        const errors = [];
+
+        while (queue.length && pages.length < maxPages) {
+            const task = queue.shift();
+            const url = this._normalizeUrl(task.url);
+            if (!url) continue;
+            if (visited.has(url)) continue;
+            if (sameSite && !this._sameSite(normalizedStart, url)) continue;
+            visited.add(url);
+
+            try {
+                const isPdfByExt = /\.pdf(?:$|\?)/i.test(url);
+                const maxBytes = isPdfByExt ? maxPdfBytes : maxBytesPerPage;
+                const fetched = await this._fetch(url, { timeoutMs, userAgent, maxBytes });
+                const ctype = fetched.contentType;
+                const isPdf = isPdfByExt || ctype.includes('application/pdf');
+
+                if (isPdf) {
+                    if (!includePdf) {
+                        pages.push({ url, kind: 'pdf', skipped: true, reason: 'includePdf=false' });
+                        continue;
+                    }
+                    const parsed = await this._parsePdf(fetched.data);
+                    pages.push({
+                        url,
+                        kind: 'pdf',
+                        bytes: fetched.bytes,
+                        contentType: ctype || 'application/pdf',
+                        pages: parsed.pages,
+                        text: (parsed.text || '').slice(0, 20000)
+                    });
+                    continue;
+                }
+
+                const html = fetched.data.toString('utf8');
+                const text = this._extractTextHtml(html);
+                const links = this._extractLinksHtml(html, url);
+                pages.push({
+                    url,
+                    kind: 'html',
+                    bytes: fetched.bytes,
+                    contentType: ctype || 'text/html',
+                    linksFound: links.length,
+                    text: text.slice(0, 20000)
+                });
+
+                if (task.depth < maxDepth) {
+                    for (const link of links) {
+                        const n = this._normalizeUrl(link);
+                        if (!n) continue;
+                        if (visited.has(n)) continue;
+                        if (sameSite && !this._sameSite(normalizedStart, n)) continue;
+                        queue.push({ url: n, depth: task.depth + 1 });
+                    }
+                }
+            } catch (e) {
+                errors.push({ url: task.url, error: e?.message || String(e) });
+            }
+        }
+
+        const chunks = [];
+        for (const p of pages) {
+            if (!p?.text) continue;
+            chunks.push(`URL: ${p.url}\n${p.text}`);
+            if (chunks.join('\n\n').length > 60000) break;
+        }
+        const aggregated = chunks.join('\n\n');
+
+        return {
+            ok: true,
+            source: 'crawl',
+            startUrl: normalizedStart,
+            stats: { visited: visited.size, returned: pages.length, queued: queue.length, errors: errors.length },
+            pages,
+            text: aggregated,
+            errors: errors.slice(0, 20)
+        };
+    }
+}
+
 class SessionManager {
     constructor(store, { idleMs = 10 * 60 * 1000, maxSessions = 200 } = {}) {
         this.store = store;
@@ -1239,6 +1602,49 @@ class SnapshotManager {
     }
 }
 
+// 图导出构建器：将线性代数结构（CSR、窗口、嵌入）反序列化为 Go 可消费的图结构
+class GraphExportBuilder {
+    static fromWindow(windowInfo, activation = null) {
+        const n = windowInfo.ids.length;
+        const coords = [];
+        // 简易坐标：若有 activation 则用前两主分量近似，否则用索引散列
+        for (let i = 0; i < n; i++) {
+            const id = windowInfo.ids[i];
+            const ax = activation && Number.isFinite(activation[i]) ? activation[i] : 0;
+            const ay = ((i * 9973) % 101) / 100;
+            coords.push([ax, ay, 0]);
+        }
+        const nodes = [];
+        for (let i = 0; i < n; i++) {
+            nodes.push({
+                id: String(windowInfo.ids[i]),
+                x: coords[i][0],
+                y: coords[i][1],
+                z: coords[i][2],
+                value: Number.isFinite(activation?.[i]) ? activation[i] : 0,
+                attrs: {}
+            });
+        }
+        const edges = [];
+        const { rowPtr, colIdx, values, nRows } = windowInfo.csr;
+        for (let r = 0; r < nRows; r++) {
+            const start = rowPtr[r];
+            const end = rowPtr[r + 1];
+            for (let k = start; k < end; k++) {
+                const c = colIdx[k];
+                const w = values[k];
+                edges.push({
+                    from: String(windowInfo.ids[r]),
+                    to: String(windowInfo.ids[c]),
+                    weight: Number.isFinite(w) ? w : 0,
+                    dir: 1
+                });
+            }
+        }
+        return { Nodes: nodes, Edges: edges };
+    }
+}
+
 class RuntimeState {
     constructor({ kvmStore, memeStore, sessionStore, params, config }) {
         this.kvm = new KVMStore(kvmStore);
@@ -1251,11 +1657,64 @@ class RuntimeState {
         this.config = { ...(config || {}) };
         this.config.robotsDir = this.config.robotsDir || path.join(__dirname, 'robots');
         this.config.lemmaCsv = this.config.lemmaCsv || path.join(__dirname, 'lemma.csv');
-        this.researcher = new OnlineResearcher(this, { endpoint: this.config.searchEndpoint });
+        // 在线搜索配置：支持运行时开关与 endpoint 库
+        this.config.search = {
+            enabled: this.config.search?.enabled ?? true,
+            endpoints: Array.isArray(this.config.search?.endpoints) ? this.config.search.endpoints : [],
+            active: typeof this.config.search?.active === 'string' ? this.config.search.active : (this.config.searchEndpoint || '')
+        };
+        // 兼容旧字段：searchEndpoint
+        if (!this.config.search.active && this.config.searchEndpoint) {
+            this.config.search.active = String(this.config.searchEndpoint);
+        }
+        // 默认库：如果没配置 endpoints 但 active 有值，则塞入库里
+        if (this.config.search.active && !this.config.search.endpoints.includes(this.config.search.active)) {
+            this.config.search.endpoints.push(this.config.search.active);
+        }
+        this.researcher = new OnlineResearcher(this, { endpoint: this.config.search.active });
+        this.researcher.enabled = Boolean(this.config.search.enabled);
         this.corpusStats = { ingested: 0, lastIngest: null };
         this.robotsCorpus = null;
     }
 
+    getSearchConfig() {
+        return {
+            enabled: Boolean(this.config.search?.enabled),
+            active: String(this.config.search?.active || ''),
+            endpoints: Array.isArray(this.config.search?.endpoints) ? this.config.search.endpoints.slice() : []
+        };
+    }
+
+    setSearchConfig(patch = {}) {
+        if (!this.config.search) {
+            this.config.search = { enabled: true, endpoints: [], active: '' };
+        }
+        if (typeof patch.enabled === 'boolean') {
+            this.config.search.enabled = patch.enabled;
+        }
+        if (Array.isArray(patch.endpoints)) {
+            const cleaned = patch.endpoints
+                .map((x) => String(x || '').trim())
+                .filter(Boolean);
+            this.config.search.endpoints = Array.from(new Set(cleaned));
+        }
+        if (typeof patch.active === 'string') {
+            const next = patch.active.trim();
+            this.config.search.active = next;
+            if (next && Array.isArray(this.config.search.endpoints) && !this.config.search.endpoints.includes(next)) {
+                this.config.search.endpoints.push(next);
+            }
+        }
+        // 同步到 researcher
+        if (this.researcher) {
+            this.researcher.endpoint = this.config.search.active || '';
+            this.researcher.enabled = Boolean(this.config.search.enabled);
+        }
+        // 兼容旧字段
+        this.config.searchEndpoint = this.config.search.active;
+        return this.getSearchConfig();
+    }
+
     cloneParams() {
         return { ...this.params };
     }
@@ -1541,6 +2000,20 @@ class RuntimeState {
             }
         }
     }
+
+    // 将当前窗口或指定种子集合导出为 Go 侧 Graph 结构并写入文件
+    exportGraphToFile({ seeds = null, radius = 2, file = null } = {}) {
+        const usedSeeds = seeds instanceof Map ? seeds : this.mapWordsToMemes(Array.isArray(seeds) ? seeds : []);
+        const win = this.graph.buildWindow(Array.from(usedSeeds.keys()), radius);
+        const act = this.tensor.iteratePropagation(win.csr, this._buildSeedVector(win, usedSeeds), this.params.iteration || 5, this._activation(), this.params.decayK, 0.02);
+        const graphObj = GraphExportBuilder.fromWindow(win, act);
+        const dir = CONFIG.exportDir || path.join(__dirname, 'runtime_store');
+        ensureDir(dir);
+        const name = `graph_export_${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+        const outFile = file ? path.resolve(file) : path.join(dir, name);
+        fs.writeFileSync(outFile, JSON.stringify(graphObj));
+        return outFile;
+    }
 }
 
 class Controller extends EventEmitter {
@@ -1592,14 +2065,38 @@ class ControllerPool extends EventEmitter {
     constructor(baseStores) {
         super();
         this.baseStores = baseStores;
-        this.controllers = {
-            A: new Controller('A', new RuntimeState(baseStores)),
-            B: new Controller('B', new RuntimeState(baseStores)),
-            C: new Controller('C', new RuntimeState(baseStores))
-        };
-        this.serving = this.controllers.A;
-        this.standby = this.controllers.B;
-        this.validation = this.controllers.C;
+        this.controllers = {};
+        this.groups = {}; // groupId -> controllerNames[]
+        const groupCount = Math.max(1, Number(baseStores?.config?.groupCount ?? CONFIG.groupCount) || 3);
+        const groupSize = Math.max(1, Number(baseStores?.config?.groupSize ?? CONFIG.groupSize) || 7);
+        this.groupIds = Array.from({ length: groupCount }, (_, i) => `G${i + 1}`);
+
+        for (const groupId of this.groupIds) {
+            const names = [];
+            const sharedStores = {
+                kvmStore: new NamespacedStore(baseStores.kvmStore, `${groupId}:kvm`),
+                memeStore: new NamespacedStore(baseStores.memeStore, `${groupId}:graph`),
+                sessionStore: new NamespacedStore(baseStores.sessionStore, `${groupId}:session`)
+            };
+            for (let i = 0; i < groupSize; i++) {
+                const name = `${groupId}_AI${i + 1}`;
+                const stores = {
+                    ...baseStores,
+                    ...sharedStores,
+                    config: { ...(baseStores.config || {}), controllerName: name, groupId, groupIndex: i + 1 }
+                };
+                this.controllers[name] = new Controller(name, new RuntimeState(stores));
+                names.push(name);
+            }
+            this.groups[groupId] = names;
+        }
+
+        // Rotation/compat: keep serving/standby/validation pointing to first group first three
+        const g1 = this.groupIds[0] || 'G1';
+        const g1Names = this.groups[g1] || Object.keys(this.controllers);
+        this.serving = this.controllers[g1Names[0]];
+        this.standby = this.controllers[g1Names[1] || g1Names[0]];
+        this.validation = this.controllers[g1Names[2] || g1Names[0]];
     }
 
     getActive() {
@@ -1607,7 +2104,29 @@ class ControllerPool extends EventEmitter {
     }
 
     getByName(name) {
-        return this.controllers[name];
+        const n = String(name || '').trim();
+        if (!n) return null;
+        // Backward compatibility: A/B/C map to G1 first 3
+        if (n === 'A' || n === 'B' || n === 'C') {
+            const g1 = this.groupIds[0] || 'G1';
+            const list = this.groups[g1] || [];
+            if (n === 'A') return this.controllers[list[0]] || null;
+            if (n === 'B') return this.controllers[list[1]] || null;
+            if (n === 'C') return this.controllers[list[2]] || null;
+        }
+        return this.controllers[n] || null;
+    }
+
+    listControllerNames() {
+        return Object.keys(this.controllers);
+    }
+
+    listGroupIds() {
+        return this.groupIds.slice();
+    }
+
+    listControllersInGroup(groupId) {
+        return (this.groups[String(groupId || '').trim()] || []).slice();
     }
 
     async hotSwap(snapshot) {
@@ -1633,6 +2152,23 @@ class ControllerPool extends EventEmitter {
         return results;
     }
 
+    async ingestDocumentTo(name, doc) {
+        const ctrl = this.getByName(name);
+        if (!ctrl) {
+            return { ok: false, reason: 'controller-not-found' };
+        }
+        return ctrl.runtime.ingestDocument(doc);
+    }
+
+    async ingestDocumentToGroup(groupId, doc) {
+        const names = this.listControllersInGroup(groupId);
+        if (!names.length) {
+            return { ok: false, reason: 'group-not-found' };
+        }
+        const results = await Promise.all(names.map((name) => this.ingestDocumentTo(name, doc)));
+        return results;
+    }
+
     async forgetMemes(criteria) {
         const results = await Promise.all(Object.values(this.controllers).map((ctrl) => ctrl.runtime.forgetMemes(criteria)));
         return results;
@@ -1729,6 +2265,7 @@ class StudyEngine {
         this.redis = redisSync;
         this.running = false;
         this.queue = [];
+        this.metrics = { enqueued: 0, processed: 0, lastTickAt: 0, lastError: null };
         this.poolWorker = workerpool.pool(CONFIG.workerFile, {
             minWorkers: 1,
             maxWorkers: CONFIG.maxWorkers,
@@ -1746,6 +2283,7 @@ class StudyEngine {
 
     enqueueDocument(doc) {
         this.queue.push(doc);
+        this.metrics.enqueued += 1;
     }
 
     async _tick() {
@@ -1754,12 +2292,24 @@ class StudyEngine {
         }
         const doc = this.queue.shift();
         try {
+            this.metrics.lastTickAt = Date.now();
             if (doc) {
                 await this.pool.ingestDocument(doc);
             }
-            await this.poolWorker.exec('ingestDocument', [doc]);
+            // memeMergeWorker.cjs 并未导出 ingestDocument，这里调用会触发：Unknown method "ingestDocument"。
+            // 保留 workerpool 管线：用 batchLemmatize 做一次轻量预处理/校验。
+            try {
+                const text = String(doc?.text || '');
+                const tokens = tokenize(text);
+                await this.poolWorker.exec('batchLemmatize', [[tokens], this.pool.getActive().runtime?.config?.lemmaCsv]);
+            } catch (_e) {
+                // ignore
+            }
+            this.metrics.processed += 1;
+            this.metrics.lastError = null;
         } catch (err) {
             console.error('[Study] worker ingest failed:', err.message);
+            this.metrics.lastError = String(err.message || err);
         }
         const snapshot = this.pool.standby.snapshot();
         await this.redis.publish(snapshot);
@@ -1833,11 +2383,13 @@ const textToMiniEmbedding = (text, dim = 64) => {
 class ShardManager {
     constructor(pool) {
         this.pool = pool;
-        this.shards = {
-            A: new ShardDescriptor('A'),
-            B: new ShardDescriptor('B'),
-            C: new ShardDescriptor('C')
-        };
+        this.shards = {};
+        const names = typeof pool?.listControllerNames === 'function'
+            ? pool.listControllerNames()
+            : Object.keys(pool?.controllers || {});
+        for (const name of names) {
+            this.shards[name] = new ShardDescriptor(name);
+        }
         this.lastEmbedding = new Float32Array(64);
     }
 
@@ -1864,7 +2416,7 @@ class ShardManager {
     }
 
     record(controllerName, requestEmbedding, replyText, latency) {
-        const shard = this.shards[controllerName];
+        const shard = this.shards[controllerName] || null;
         if (!shard) {
             return;
         }
@@ -1898,15 +2450,285 @@ const buildVariants = (text, count = 0) => {
     return variants;
 };
 
+const clamp01 = (x) => Math.max(0, Math.min(1, x));
+const clamp11 = (x) => Math.max(-1, Math.min(1, x));
+
+const makeRng = (seed) => {
+    // xorshift32
+    let x = (seed >>> 0) || 0x9e3779b9;
+    return () => {
+        x ^= x << 13;
+        x ^= x >>> 17;
+        x ^= x << 5;
+        return ((x >>> 0) / 0xffffffff);
+    };
+};
+
+class PersonaForestAverager {
+    constructor(options = {}) {
+        this.enabled = options.enabled !== false;
+        this.trees = Math.max(8, Number(options.trees ?? 32) || 32);
+        this.featureSubspace = Math.max(2, Number(options.featureSubspace ?? 4) || 4);
+        this.sampleRate = clamp01(Number(options.sampleRate ?? 0.85) || 0.85);
+        this.personaMomentum = clamp01(Number(options.personaMomentum ?? 0.92) || 0.92);
+        this.targetReplyLen = Math.max(20, Number(options.targetReplyLen ?? 220) || 220);
+        this.maxHistory = Math.max(10, Number(options.maxHistory ?? 60) || 60);
+        this.globalPersona = null; // Float32Array
+        this.controllerPersona = new Map(); // name -> Float32Array
+    }
+
+    _blendPersona(prev, next, momentum) {
+        if (!next) return prev;
+        if (!prev) return Float32Array.from(next);
+        const out = new Float32Array(prev.length);
+        for (let i = 0; i < prev.length; i++) {
+            const v = (momentum * prev[i]) + ((1 - momentum) * next[i]);
+            out[i] = Number.isFinite(v) ? v : 0;
+        }
+        return out;
+    }
+
+    _centroid(vecs, dim) {
+        if (!Array.isArray(vecs) || vecs.length === 0) return null;
+        const out = new Float32Array(dim);
+        let count = 0;
+        for (const v of vecs) {
+            if (!v || v.length !== dim) continue;
+            for (let i = 0; i < dim; i++) out[i] += v[i];
+            count += 1;
+        }
+        if (!count) return null;
+        for (let i = 0; i < dim; i++) out[i] /= count;
+        return out;
+    }
+
+    _tokenOverlapRatio(aTokens, bTokens) {
+        if (!aTokens.length || !bTokens.length) return 0;
+        const setB = new Set(bTokens);
+        let hit = 0;
+        for (const t of aTokens) if (setB.has(t)) hit += 1;
+        return hit / Math.max(1, aTokens.length);
+    }
+
+    _variantStability(controller) {
+        const variants = controller?.variants;
+        if (!Array.isArray(variants) || variants.length === 0) return 0.5;
+        let sum = 0;
+        let n = 0;
+        for (const v of variants) {
+            if (!v || !v.response || typeof v.affinity !== 'number') continue;
+            if (!Number.isFinite(v.affinity)) continue;
+            sum += clamp11(v.affinity);
+            n += 1;
+        }
+        if (!n) return 0.5;
+        // map [-1,1] -> [0,1]
+        return clamp01((sum / n + 1) / 2);
+    }
+
+    pick({ payload, layerResults, requestEmbedding, history = [] }) {
+        if (!this.enabled) {
+            return null;
+        }
+        const dim = requestEmbedding?.length ?? 64;
+        const inputText = String(payload?.text || '');
+        const inputTokens = tokenize(inputText);
+
+        const candidates = [];
+        for (const layer of layerResults || []) {
+            for (const controller of layer.controllers || []) {
+                const base = controller?.base;
+                const reply = base?.reply;
+                if (!base || !reply) continue;
+                const emb = textToMiniEmbedding(String(reply), dim);
+                const affinity = Number.isFinite(controller.affinity) ? clamp11(controller.affinity) : clamp11(cosineSim(requestEmbedding, emb));
+                candidates.push({
+                    layer: layer.layer,
+                    controller: controller.controller,
+                    reply: String(reply),
+                    latency: base.latency,
+                    sessionId: base.sessionId,
+                    affinity,
+                    emb,
+                    controllerRef: controller
+                });
+            }
+        }
+
+        if (candidates.length === 0) return null;
+        if (candidates.length === 1) {
+            const only = candidates[0];
+            this._updatePersonas(only);
+            return { ...only, score: 0, method: 'forest-single' };
+        }
+
+        const candidateEmbeddings = candidates.map((c) => c.emb);
+        const consensusCentroid = this._centroid(candidateEmbeddings, dim);
+        const lastAgg = Array.isArray(history) && history.length ? history[history.length - 1]?.aggregate : null;
+        const lastReplyEmb = lastAgg?.reply ? textToMiniEmbedding(String(lastAgg.reply), dim) : null;
+        const lastReplyLen = typeof lastAgg?.reply === 'string' ? lastAgg.reply.length : null;
+        const targetLen = Number.isFinite(lastReplyLen) && lastReplyLen > 20 ? lastReplyLen : this.targetReplyLen;
+
+        // feature extraction
+        for (const c of candidates) {
+            const replyTokens = tokenize(c.reply);
+            const overlap = this._tokenOverlapRatio(inputTokens, replyTokens); // 0..1
+            const consensus = consensusCentroid ? clamp11(cosineSim(c.emb, consensusCentroid)) : 0;
+            const personaCoherence = this.globalPersona ? clamp11(cosineSim(c.emb, this.globalPersona)) : 0;
+            const ctrlPersona = this.controllerPersona.get(c.controller);
+            const controllerCoherence = ctrlPersona ? clamp11(cosineSim(c.emb, ctrlPersona)) : 0;
+            const novelty = lastReplyEmb ? clamp01(1 - ((clamp11(cosineSim(c.emb, lastReplyEmb)) + 1) / 2)) : 0.5;
+            const lenPenalty = -clamp01(Math.abs(c.reply.length - targetLen) / Math.max(40, targetLen));
+            const stability = this._variantStability(c.controllerRef);
+            const latencyNorm = Number.isFinite(c.latency) ? clamp01(1 - (Number(c.latency) / 2000)) : 0.5;
+            c.features = {
+                affinity: clamp01((c.affinity + 1) / 2),
+                overlap,
+                consensus: clamp01((consensus + 1) / 2),
+                persona: clamp01((personaCoherence + 1) / 2),
+                controllerPersona: clamp01((controllerCoherence + 1) / 2),
+                novelty,
+                lenPenalty: clamp01(1 + lenPenalty), // [-1,0] -> [0,1]
+                stability,
+                latency: latencyNorm
+            };
+        }
+
+        const featureNames = Object.keys(candidates[0].features);
+        const seedText = `${payload?.sessionId || ''}|${hashStrSimple(inputText)}|${candidates.length}`;
+        const rng = makeRng(hashStrSimple(seedText));
+
+        const scores = new Map();
+        const votes = new Map();
+        for (const c of candidates) {
+            scores.set(c, 0);
+            votes.set(c, 0);
+        }
+
+        const pickSubspace = () => {
+            const chosen = new Set();
+            const maxPick = Math.min(this.featureSubspace, featureNames.length);
+            while (chosen.size < maxPick) {
+                const idx = Math.floor(rng() * featureNames.length);
+                chosen.add(featureNames[idx]);
+            }
+            return Array.from(chosen);
+        };
+
+        for (let t = 0; t < this.trees; t++) {
+            const subspace = pickSubspace();
+            // random weights per tree, with mild bias toward affinity/consensus/persona
+            const weights = {};
+            for (const f of subspace) {
+                let w = (rng() * 2 - 1);
+                if (f === 'affinity' || f === 'consensus' || f === 'persona') w *= 1.4;
+                if (f === 'controllerPersona' || f === 'stability') w *= 1.1;
+                if (f === 'novelty') w *= 0.6;
+                weights[f] = w;
+            }
+
+            // bagging candidates
+            const bag = candidates.filter(() => rng() <= this.sampleRate);
+            const bagCandidates = bag.length >= 2 ? bag : candidates;
+
+            let best = null;
+            let bestScore = -Infinity;
+            for (const c of bagCandidates) {
+                let s = 0;
+                for (const f of subspace) {
+                    const v = c.features[f];
+                    s += weights[f] * (Number.isFinite(v) ? v : 0);
+                }
+                if (s > bestScore) {
+                    bestScore = s;
+                    best = c;
+                }
+            }
+            if (best) {
+                votes.set(best, (votes.get(best) || 0) + 1);
+            }
+            // accumulate soft score for all candidates to enable tie-breaks
+            for (const c of candidates) {
+                let s = 0;
+                for (const f of subspace) {
+                    const v = c.features[f];
+                    s += weights[f] * (Number.isFinite(v) ? v : 0);
+                }
+                scores.set(c, (scores.get(c) || 0) + s);
+            }
+        }
+
+        const ranked = candidates
+            .map((c) => ({
+                c,
+                votes: votes.get(c) || 0,
+                score: (scores.get(c) || 0) / Math.max(1, this.trees)
+            }))
+            .sort((a, b) => (b.votes - a.votes) || (b.score - a.score) || (b.c.features.consensus - a.c.features.consensus) || (b.c.features.affinity - a.c.features.affinity));
+
+        const winner = ranked[0]?.c;
+        if (!winner) return null;
+
+        this._updatePersonas(winner);
+        const picked = {
+            layer: winner.layer,
+            controller: winner.controller,
+            affinity: winner.affinity,
+            reply: winner.reply,
+            latency: winner.latency,
+            sessionId: winner.sessionId,
+            score: ranked[0].score,
+            votes: ranked[0].votes,
+            method: 'persona-forest'
+        };
+        return picked;
+    }
+
+    _updatePersonas(winner) {
+        if (!winner?.emb) return;
+        const next = winner.emb;
+        this.globalPersona = this._blendPersona(this.globalPersona, next, this.personaMomentum);
+        const prevCtrl = this.controllerPersona.get(winner.controller) || null;
+        this.controllerPersona.set(winner.controller, this._blendPersona(prevCtrl, next, this.personaMomentum));
+
+        // keep map bounded
+        if (this.controllerPersona.size > 64) {
+            const keys = Array.from(this.controllerPersona.keys());
+            while (this.controllerPersona.size > 64) {
+                this.controllerPersona.delete(keys[Math.floor(Math.random() * keys.length)]);
+            }
+        }
+    }
+}
+
 class SparkArray {
-    constructor(pool, shardManager) {
+    /**
+     * @param {ControllerPool} pool
+     * @param {ShardManager} shardManager
+     * @param {Object} [options]
+     * @param {number} [options.numAI] - 对话AI数量，默认7
+     * @param {Array} [options.layers] - 自定义层结构
+     */
+    constructor(pool, shardManager, options = {}) {
         this.pool = pool;
         this.shardManager = shardManager;
-        this.layers = [
-            { name: 'alpha', controllers: ['A'], strategy: 'max' },
-            { name: 'beta', controllers: ['B'], strategy: 'max' },
-            { name: 'gamma', controllers: ['C'], strategy: 'max' }
-        ];
+        this.groupId = String(options.groupId || (typeof pool?.listGroupIds === 'function' ? (pool.listGroupIds()[0] || 'G1') : 'G1'));
+        const available = typeof pool?.listControllersInGroup === 'function'
+            ? pool.listControllersInGroup(this.groupId)
+            : (typeof pool?.listControllerNames === 'function' ? pool.listControllerNames() : Object.keys(pool?.controllers || {}));
+        const wanted = 7; // 每个工作组固定 7 个 AI
+        const numAI = Math.max(1, Math.min(available.length || wanted, wanted));
+        // 组内小 SparkArray：固定 7 个 AI（不足则截断）
+        this.layers = Array.from({ length: numAI }, (_, i) => ({
+            name: `${this.groupId}:a${i + 1}`,
+            controllers: [available[i]],
+            strategy: 'max'
+        }));
+        // 如果外部传入自定义层结构则覆盖
+        if (Array.isArray(options.layers) && options.layers.length > 0) {
+            this.layers = options.layers.map((layer) => ({ strategy: 'max', ...layer }));
+        }
+        this.personaForest = new PersonaForestAverager(options.personaForest || {});
         this.history = [];
     }
 
@@ -1934,14 +2756,24 @@ class SparkArray {
 
         for (const layer of layers) {
             const controllers = [];
-            for (const controllerName of layer.controllers) {
+            for (const controllerSpec of layer.controllers) {
+                const controllerName = typeof controllerSpec === 'string'
+                    ? controllerSpec
+                    : String(controllerSpec?.name || controllerSpec?.controller || '').trim();
+                const weightRaw = typeof controllerSpec === 'object' && controllerSpec
+                    ? (controllerSpec.weight ?? controllerSpec.w)
+                    : 1;
+                const weight = Math.max(1, Math.min(8, Math.round(Number(weightRaw) || 1)));
                 const ctrl = this.pool.getByName(controllerName);
                 if (!ctrl || !ctrl.online) {
                     continue;
                 }
                 let baseResult;
                 try {
-                    baseResult = await ctrl.respond(payload);
+                    const weightedText = weight <= 1
+                        ? String(payload.text || '')
+                        : Array.from({ length: weight }, () => String(payload.text || '')).join(' ');
+                    baseResult = await ctrl.respond({ ...payload, text: weightedText });
                 } catch (err) {
                     controllers.push({
                         controller: controllerName,
@@ -1977,12 +2809,33 @@ class SparkArray {
             layerResults.push({ layer: layer.name, controllers });
         }
 
-        const aggregate = this._aggregate(layerResults);
+        const aggregate = this._aggregate(layerResults, payload, requestEmbedding);
         this._recordHistory(payload, aggregate, layerResults);
         return { aggregate, layers: layerResults };
     }
 
-    _aggregate(layerResults) {
+    // 多轮“大 SparkArray”：用上一轮 aggregate 作为下一轮输入以修补缝隙
+    async dispatchBig(payload, options = {}) {
+        const rounds = Math.max(1, Math.min(10, Number(options.bigRounds ?? options.bigSparkRounds ?? 1) || 1));
+        const history = [];
+        let current = { ...(payload || {}) };
+        const originalText = String(current.text || '');
+        for (let i = 0; i < rounds; i++) {
+            const r = await this.dispatch(current, options);
+            history.push(r);
+            const reply = r?.aggregate?.reply ? String(r.aggregate.reply) : '';
+            if (!reply.trim()) {
+                break;
+            }
+            // 以“原问题 + 上轮回答”为下一轮输入，长度做截断避免爆炸
+            const combined = `${originalText}\n${reply}`;
+            current = { ...current, text: combined.slice(-4000) };
+        }
+        const last = history[history.length - 1] || { aggregate: null, layers: [] };
+        return { ...last, rounds: history };
+    }
+
+    _aggregate(layerResults, payload = {}, requestEmbedding = null) {
         let best = null;
         for (const layer of layerResults) {
             for (const controller of layer.controllers) {
@@ -1996,11 +2849,37 @@ class SparkArray {
                         affinity: controller.affinity,
                         reply: controller.base.reply,
                         latency: controller.base.latency,
-                        sessionId: controller.base.sessionId
+                        sessionId: controller.base.sessionId,
+                        method: 'max-affinity'
                     };
                 }
             }
         }
+
+        // 随机森林式“中途平均/投票”：在不改变对外结构的前提下，优先选择更稳定且共识更强的回复
+        try {
+            const picked = this.personaForest.pick({
+                payload: { text: payload?.text || '', sessionId: payload?.sessionId },
+                layerResults,
+                requestEmbedding: requestEmbedding || textToMiniEmbedding(payload?.text || '', 64),
+                history: this.history.slice(-this.personaForest.maxHistory)
+            });
+            if (picked && picked.reply) {
+                return {
+                    layer: picked.layer,
+                    controller: picked.controller,
+                    affinity: picked.affinity,
+                    reply: picked.reply,
+                    latency: picked.latency,
+                    sessionId: picked.sessionId,
+                    method: picked.method,
+                    score: picked.score,
+                    votes: picked.votes
+                };
+            }
+        } catch (err) {
+            // fall back to old behavior
+        }
         return best;
     }
 
@@ -2017,54 +2896,862 @@ class SparkArray {
     }
 }
 
-class GatewayServer {
-    constructor(pool, shardManager, snapshotManager, rotation, redisSync, study, sparkArray) {
+class BigSparkArray {
+    constructor(pool, shardManager, options = {}) {
         this.pool = pool;
-        this.shards = shardManager;
-        this.snapshots = snapshotManager;
-        this.rotation = rotation;
-        this.redisSync = redisSync;
-        this.study = study;
-        this.spark = sparkArray || new SparkArray(pool, shardManager);
-        this.app = express();
-        this.app.use(bodyParser.json({ limit: '10mb' }));
-        this.app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
-        this._setupRoutes();
+        this.shardManager = shardManager;
+        const groupIds = Array.isArray(options.groupIds) && options.groupIds.length
+            ? options.groupIds
+            : (typeof pool?.listGroupIds === 'function' ? pool.listGroupIds() : ['G1']);
+        this.groups = groupIds.map((groupId) => ({
+            groupId,
+            weight: Math.max(1, Math.min(8, Math.round(Number(options?.groupWeights?.[groupId] ?? 1) || 1))),
+            spark: new SparkArray(pool, shardManager, { groupId, ...(options.groupOptions || {}) })
+        }));
+        this.personaForest = new PersonaForestAverager(options.personaForest || {});
+        this.history = [];
     }
 
-    _setupRoutes() {
-        const sendHtml = (res, file) => {
-            const full = path.join(__dirname, 'public', file);
-            fs.readFile(full, 'utf8', (err, data) => {
-                if (err) {
-                    res.status(404).send('Not found');
-                    return;
-                }
-                res.setHeader('Content-Type', 'text/html; charset=utf-8');
-                res.send(data);
-            });
-        };
-
-        this.app.get('/', (req, res) => {
-            sendHtml(res, 'index.html');
-        });
+    getLayers() {
+        return this.groups.map((g) => ({ groupId: g.groupId, weight: g.weight, layers: g.spark.getLayers() }));
+    }
 
-        this.app.get('/:page(index.html|indexmain.html|chat_straight.html|monitor.html)', (req, res) => {
-            sendHtml(res, req.params.page);
-        });
+    updateLayers(patch) {
+        // 兼容旧端点：如果传入数组，当作更新第一个工作组的小阵列
+        if (Array.isArray(patch)) {
+            this.groups[0]?.spark?.updateLayers(patch);
+            return;
+        }
+        // 也支持 { groupId, layers }
+        const groupId = String(patch?.groupId || '').trim();
+        const layers = patch?.layers;
+        if (groupId && Array.isArray(layers)) {
+            const g = this.groups.find((x) => x.groupId === groupId);
+            if (g) g.spark.updateLayers(layers);
+        }
+    }
+
+    async dispatch(payload, options = {}) {
+        const requestEmbedding = textToMiniEmbedding(payload?.text || '', 64);
+        const groupResults = [];
+
+        for (const g of this.groups) {
+            const groupPayload = { ...(payload || {}) };
+            // 组权重：同样体现在文本重复次数（组级别风格/偏好）
+            const w = Math.max(1, g.weight);
+            if (w > 1) {
+                const t = String(groupPayload.text || '');
+                groupPayload.text = Array.from({ length: w }, () => t).join(' ');
+            }
+            const result = await g.spark.dispatch(groupPayload, options);
+            groupResults.push({ groupId: g.groupId, result });
+        }
+
+        // 组间聚合：将每个工作组的 aggregate 当作候选，做随机森林式投票/共识
+        const layerResults = [
+            {
+                layer: 'groups',
+                controllers: groupResults.map((gr) => {
+                    const agg = gr?.result?.aggregate;
+                    return {
+                        controller: gr.groupId,
+                        base: agg ? { reply: agg.reply, latency: agg.latency, sessionId: agg.sessionId } : null,
+                        affinity: agg ? clamp11(Number(agg.affinity ?? 0)) : 0,
+                        variants: []
+                    };
+                })
+            }
+        ];
+
+        let aggregate = null;
+        try {
+            const picked = this.personaForest.pick({
+                payload: { text: payload?.text || '', sessionId: payload?.sessionId },
+                layerResults,
+                requestEmbedding,
+                history: this.history.slice(-this.personaForest.maxHistory)
+            });
+            if (picked && picked.reply) {
+                aggregate = {
+                    layer: 'groups',
+                    controller: picked.controller,
+                    affinity: picked.affinity,
+                    reply: picked.reply,
+                    latency: picked.latency,
+                    sessionId: picked.sessionId,
+                    method: picked.method,
+                    score: picked.score,
+                    votes: picked.votes
+                };
+            }
+        } catch (_e) {
+            // ignore
+        }
+        if (!aggregate) {
+            // fallback：选择 reply 非空且 affinity 最大的组
+            let best = null;
+            for (const gr of groupResults) {
+                const agg = gr?.result?.aggregate;
+                if (!agg || !agg.reply) continue;
+                const a = Number.isFinite(agg.affinity) ? agg.affinity : 0;
+                if (!best || a > best.affinity) {
+                    best = { ...agg, controller: gr.groupId, layer: 'groups' };
+                }
+            }
+            aggregate = best;
+        }
+
+        const out = { aggregate, groups: groupResults };
+        this.history.push({ ts: Date.now(), request: { text: payload?.text, sessionId: payload?.sessionId }, aggregate, groups: groupResults });
+        if (this.history.length > 100) this.history.shift();
+        return out;
+    }
+
+    async dispatchBig(payload, options = {}) {
+        const rounds = Math.max(1, Math.min(10, Number(options.bigRounds ?? options.bigSparkRounds ?? 1) || 1));
+        const history = [];
+        let current = { ...(payload || {}) };
+        const originalText = String(current.text || '');
+        for (let i = 0; i < rounds; i++) {
+            const r = await this.dispatch(current, options);
+            history.push(r);
+            const reply = r?.aggregate?.reply ? String(r.aggregate.reply) : '';
+            if (!reply.trim()) break;
+            const combined = `${originalText}\n${reply}`;
+            current = { ...current, text: combined.slice(-4000) };
+        }
+        const last = history[history.length - 1] || { aggregate: null, groups: [] };
+        return { ...last, rounds: history };
+    }
+}
+
+// 模因阻断模块 - 识别并隔离恶性模因（参考实验版）
+class MemeBarrier {
+    constructor(runtime, {
+        scanIntervalMs = 10_000,
+        maliciousThreshold = 0.7,
+        maxIsolatePerScan = 5
+    } = {}) {
+        this.runtime = runtime;
+        this.scanIntervalMs = scanIntervalMs;
+        this.maliciousThreshold = maliciousThreshold;
+        this.maxIsolatePerScan = maxIsolatePerScan;
+        this.timer = null;
+        this.stats = { scans: 0, isolated: 0, lastScanTime: 0, lastIsolated: [] };
+    }
+
+    start() {
+        if (this.timer) return;
+        this.timer = setInterval(() => {
+            try { this.scanNetwork(); } catch (e) { console.error('[MemeBarrier] 扫描错误:', e); }
+        }, this.scanIntervalMs);
+        this.running = true;
+        console.log('[MemeBarrier] 已启动');
+    }
+
+    stop() {
+        if (this.timer) { clearInterval(this.timer); this.timer = null; }
+        this.running = false;
+        console.log('[MemeBarrier] 已停止');
+    }
+
+    generateReason(meme, score) {
+        const conn = meme.connect || [];
+        return `score=${score.toFixed(3)} conn=${conn.length}`;
+    }
+
+    evaluateMaliciousness(meme) {
+        const conn = meme.connect || [];
+        const degree = conn.length;
+        const selfLoops = conn.filter(([w, pid, dir]) => pid === meme.pointID).length;
+        const outDegree = conn.filter(([w, pid, dir]) => dir === 2).length;
+        // 访问增长近似
+        let growth = 0;
+        try {
+            const access = this.runtime.wordAccessLog?.get(meme.pointID);
+            if (access && access.size) {
+                const total = Array.from(access.values()).reduce((a, b) => a + b, 0);
+                growth = Math.min(1, Math.log1p(total) / 10);
+            }
+        } catch (_) {}
+        const avgConn = this.getAverageConnections();
+        const outSkew = avgConn > 0 ? Math.min(1, outDegree / (avgConn * 3)) : 0;
+        const selfSkew = degree > 0 ? Math.min(1, selfLoops / degree) : 0;
+        return 0.5 * growth + 0.3 * outSkew + 0.2 * selfSkew;
+    }
+
+    getAverageConnections() {
+        const points = this.runtime.graph.getAllPoints();
+        if (!points.length) return 0;
+        const sum = points.reduce((acc, p) => acc + (p.connect?.length || 0), 0);
+        return sum / points.length;
+    }
+
+    isolateMeme(memeID, score, reason) {
+        const point = this.runtime.graph.points.get(memeID);
+        if (!point) return false;
+        const conn = point.connect || [];
+        let cut = 0;
+        for (let i = conn.length - 1; i >= 0; i--) {
+            const [w, pid, dir] = conn[i];
+            if (dir === 2) { // 出边
+                conn.splice(i, 1);
+                cut++;
+                const target = this.runtime.graph.points.get(pid);
+                if (target && target.connect) {
+                    for (let j = target.connect.length - 1; j >= 0; j--) {
+                        const [tw, tpid, tdir] = target.connect[j];
+                        if (tpid === memeID && tdir === 1) { // 目标的入边
+                            target.connect.splice(j, 1);
+                        }
+                    }
+                }
+            }
+        }
+        this.stats.isolated++;
+        this.stats.lastIsolated.unshift({ memeID, score, reason, cut });
+        this.stats.lastIsolated = this.stats.lastIsolated.slice(0, 20);
+        console.log(`[MemeBarrier] 隔离 ${memeID}: cut=${cut} ${reason}`);
+        return cut > 0;
+    }
+
+    scanNetwork() {
+        const points = this.runtime.graph.getAllPoints();
+        this.stats.scans++;
+        this.stats.lastScanTime = Date.now();
+        if (!points.length) return;
+        const scored = points.map(p => {
+            const s = this.evaluateMaliciousness(p);
+            return { id: p.pointID, meme: p, score: s, reason: this.generateReason(p, s) };
+        }).sort((a, b) => b.score - a.score);
+        let isolated = 0;
+        for (const item of scored) {
+            if (item.score >= this.maliciousThreshold) {
+                if (this.isolateMeme(item.id, item.score, item.reason)) {
+                    isolated++;
+                    if (isolated >= this.maxIsolatePerScan) break;
+                }
+            } else { break; }
+        }
+        if (isolated > 0) {
+            console.log(`[MemeBarrier] 本次扫描隔离 ${isolated} 个可疑模因`);
+        }
+    }
 
-        this.app.get('/favicon.ico', (_req, res) => {
-            res.status(204).end();
+    getStats() { return { ...this.stats }; }
+}
+
+// 强化学习模块：基于线性代数与可选外部库的评估-更新循环
+class ReinforcementLearner {
+    constructor(pool, {
+        testsDir = path.join(__dirname, 'tests'),
+        maxDocs = 64,
+        topKWords = 30,
+        improvementThreshold = 0.01,
+        iterations = 5,
+        useUmap = true
+    } = {}) {
+        this.pool = pool;
+        this.testsDir = testsDir;
+        this.maxDocs = maxDocs;
+        this.topKWords = topKWords;
+        this.iterations = iterations;
+        this.useUmap = useUmap;
+        this.improvementThreshold = improvementThreshold;
+        this.history = [];
+        // 统一使用上方安全引用的 Matrix（可能为 null）
+        this.Matrix = Matrix;
+        this.kmeans = safeRequire('ml-kmeans');
+        this.numeric = safeRequire('numeric');
+    }
+
+    _listTestFiles() {
+        if (!fs.existsSync(this.testsDir)) {
+            return [];
+        }
+        return fs.readdirSync(this.testsDir)
+            .filter((n) => n.toLowerCase().endsWith('.txt'))
+            .sort((a, b) => a.localeCompare(b))
+            .slice(0, this.maxDocs);
+    }
+
+    _readText(file) {
+        try {
+            return fs.readFileSync(path.join(this.testsDir, file), 'utf8');
+        } catch (err) {
+            return '';
+        }
+    }
+
+    _scoreReplyQuality(reply, seeds) {
+        const words = tokenize(reply);
+        if (!words.length) return 0;
+        let coverage = 0;
+        for (const [memeId, strength] of seeds.entries()) {
+            const linked = this.pool.getActive().runtime.kvm.getMemeWords(memeId);
+            if (!linked || linked.size === 0) continue;
+            let hit = 0;
+            for (const w of words) {
+                if (linked.has(w)) { hit += 1; }
+            }
+            coverage += hit / Math.max(1, linked.size);
+        }
+        coverage = coverage / Math.max(1, seeds.size);
+        const uniq = new Set(words).size / Math.max(1, words.length);
+        return 0.7 * coverage + 0.3 * uniq;
+    }
+
+    _buildFeatureForDoc(text) {
+        const vec = textToMiniEmbedding(text, 128);
+        return Array.from(vec);
+    }
+
+    _reduceFeatures(features) {
+        if (this.Matrix) {
+            const X = new this.Matrix(features);
+            // 简易 PCA：协方差 + 特征分解（若 numeric 可用）
+            if (this.numeric) {
+                try {
+                    const mean = X.mean('row');
+                    const centered = X.clone();
+                    for (let i = 0; i < centered.rows; i++) {
+                        centered.setRow(i, centered.getRow(i).map((v, j) => v - mean[j]));
+                    }
+                    const Xt = centered.transpose();
+                    const cov = Xt.mmul(centered).div(Math.max(1, centered.rows - 1));
+                    // 使用 numeric 进行特征分解
+                    const covArr = cov.to2DArray();
+                    const eig = this.numeric.eig(covArr);
+                    const vectors = eig.E?.x || eig.E; // 列为特征向量
+                    if (!vectors) throw new Error('eig-vectors-missing');
+                    const v1 = vectors.map((row) => row[0]);
+                    const v2 = vectors.map((row) => row[1] ?? 0);
+                    const coords = [];
+                    for (let i = 0; i < centered.rows; i++) {
+                        const r = centered.getRow(i);
+                        const x = r.reduce((acc, v, j) => acc + v * (v1[j] ?? 0), 0);
+                        const y = r.reduce((acc, v, j) => acc + v * (v2[j] ?? 0), 0);
+                        coords.push([x, y]);
+                    }
+                    return coords;
+                } catch (err) {
+                    // numeric.eig 不收敛或失败时，回退到内置 PCA
+                    const reducer = new DimReducer();
+                    const emb = { data: Float32Array.from(features.flat()), nRows: features.length, nCols: features[0]?.length || 1 };
+                    const proj = reducer.project2D(emb, 'pca');
+                    return proj.coords;
+                }
+            }
+            // 回退：基于随机投影的近似降维
+            const D = X.columns;
+            const rp1 = Array.from({ length: D }, () => Math.random() - 0.5);
+            const rp2 = Array.from({ length: D }, () => Math.random() - 0.5);
+            const coords = [];
+            for (let i = 0; i < X.rows; i++) {
+                const row = X.getRow(i);
+                const x = row.reduce((acc, v, j) => acc + v * rp1[j], 0);
+                const y = row.reduce((acc, v, j) => acc + v * rp2[j], 0);
+                coords.push([x, y]);
+            }
+            return coords;
+        }
+        // 无外部库：使用已有 DimReducer 的 PCA
+        const bridge = new GraphTensorBridge(this.pool.getActive().runtime);
+        const reducer = new DimReducer();
+        const emb = { data: Float32Array.from(features.flat()), nRows: features.length, nCols: features[0]?.length || 1 };
+        const proj = reducer.project2D(emb, 'pca');
+        return proj.coords;
+    }
+
+    _cluster(coords, k = 3) {
+        if (this.kmeans) {
+            try {
+                const out = this.kmeans(coords, k);
+                return out.clusters;
+            } catch (err) {
+                // 回退到简单阈值聚类
+            }
+        }
+        // 简易聚类：按 x 坐标等距切分
+        const xs = coords.map((c) => c[0]);
+        const min = Math.min(...xs);
+        const max = Math.max(...xs);
+        const step = (max - min) / Math.max(1, k);
+        return coords.map((c) => Math.min(k - 1, Math.max(0, Math.floor((c[0] - min) / Math.max(step, 1e-6)))));
+    }
+
+    _adjustParams(evalStats) {
+        const active = this.pool.getActive();
+        const params = active.runtime.cloneParams();
+        const baseScore = evalStats.baseAvg;
+        const learnedScore = evalStats.learnedAvg;
+        if (learnedScore - baseScore >= this.improvementThreshold) {
+            params.iteration = Math.min(12, (params.iteration || 5) + 1);
+            params.decayK = Math.max(0.5, (params.decayK || 1) - 0.05);
+        } else {
+            params.iteration = Math.max(3, (params.iteration || 5) - 1);
+            params.decayK = Math.min(2.0, (params.decayK || 1) + 0.05);
+        }
+        active.applyParams(params);
+        return params;
+    }
+
+    async evaluateOnce(file) {
+        const text = this._readText(file);
+        const ctrl = this.pool.getActive();
+        const response = await ctrl.respond({ text });
+        const seeds = new Map(response.seeds);
+        const score = this._scoreReplyQuality(response.reply, seeds);
+        return { file, score, words: tokenize(text), reply: response.reply };
+    }
+
+    async learn(cycles = 3) {
+        const files = this._listTestFiles();
+        const evals = [];
+        for (const file of files) {
+            evals.push(await this.evaluateOnce(file));
+        }
+        const features = evals.map((e) => this._buildFeatureForDoc(e.reply));
+        const coords = this._reduceFeatures(features);
+        const clusters = this._cluster(coords, Math.min(4, Math.max(2, Math.floor(Math.sqrt(files.length)) )));
+        const grouped = new Map();
+        for (let i = 0; i < evals.length; i++) {
+            const g = clusters[i] ?? 0;
+            if (!grouped.has(g)) grouped.set(g, []);
+            grouped.get(g).push(evals[i]);
+        }
+        const clusterStats = Array.from(grouped.entries()).map(([gid, arr]) => ({ gid, avg: arr.reduce((a, b) => a + b.score, 0) / Math.max(1, arr.length), n: arr.length }));
+        const baseAvg = evals.reduce((a, b) => a + b.score, 0) / Math.max(1, evals.length);
+        const learnedAvg = clusterStats.reduce((a, b) => a + b.avg, 0) / Math.max(1, clusterStats.length);
+        const evalStats = { baseAvg, learnedAvg, clusters: clusterStats };
+        const newParams = this._adjustParams(evalStats);
+        this.history.push({ ts: Date.now(), evals, evalStats, params: newParams });
+        return { ok: true, evalStats, params: newParams };
+    }
+
+    latest() {
+        return this.history[this.history.length - 1] || null;
+    }
+}
+
+// 对抗学习模块：模拟扰动、生成对手样本、鲁棒性评估与修复
+class AdversarialLearner {
+    constructor(pool, {
+        maxAdversaries = 64,
+        noiseLevel = 0.2,
+        synonymMap = null,
+        attackRounds = 3,
+        defenseRounds = 3,
+        benchLimit = 50
+    } = {}) {
+        this.pool = pool;
+        this.maxAdversaries = maxAdversaries;
+        this.noiseLevel = noiseLevel;
+        this.synonymMap = synonymMap || new Map();
+        this.attackRounds = attackRounds;
+        this.defenseRounds = defenseRounds;
+        this.benchLimit = benchLimit;
+        this.rng = safeRequire('seedrandom') ? safeRequire('seedrandom')('phoenix-adv') : Math.random;
+        this.history = [];
+        this.Matrix = safeRequire('ml-matrix');
+    }
+
+    _perturbTokens(tokens) {
+        const out = [];
+        for (const t of tokens) {
+            const r = (typeof this.rng === 'function') ? this.rng() : Math.random();
+            if (r < this.noiseLevel / 2) {
+                // 删除 token
+                continue;
+            }
+            if (r < this.noiseLevel) {
+                // 同义替换
+                const syns = this.synonymMap.get(t);
+                if (Array.isArray(syns) && syns.length) {
+                    out.push(syns[Math.floor(r * syns.length)]);
+                    continue;
+                }
+            }
+            out.push(t);
+        }
+        // 随机插入噪声 token
+        if ((typeof this.rng === 'function' ? this.rng() : Math.random()) < this.noiseLevel) {
+            out.push('noise_token_' + Math.floor(((typeof this.rng === 'function') ? this.rng() : Math.random()) * 1000));
+        }
+        return out;
+    }
+
+    _generateAdversaries(text) {
+        const base = tokenize(text);
+        const adversaries = [];
+        for (let i = 0; i < Math.min(8, Math.max(2, Math.floor(base.length / 3))); i++) {
+            const mut = this._perturbTokens(base);
+            adversaries.push(mut.join(' '));
+        }
+        return adversaries;
+    }
+
+    async _probe(text) {
+        const ctrl = this.pool.getActive();
+        const result = await ctrl.respond({ text });
+        const seeds = new Map(result.seeds);
+        const quality = this._qualityMetric(result.reply, seeds);
+        return { text, reply: result.reply, quality, latency: result.latency, seeds };
+    }
+
+    _qualityMetric(reply, seeds) {
+        // 与强化评分一致，但加入长度惩罚与重复惩罚
+        const base = tokenize(reply);
+        if (!base.length) return 0;
+        const linkedHit = this._linkedCoverage(base, seeds);
+        const uniq = new Set(base).size / Math.max(1, base.length);
+        const lenPenalty = base.length > 50 ? 0.9 : 1.0;
+        return (0.6 * linkedHit + 0.4 * uniq) * lenPenalty;
+    }
+
+    _linkedCoverage(words, seeds) {
+        let coverage = 0;
+        for (const [memeId] of seeds.entries()) {
+            const linked = this.pool.getActive().runtime.kvm.getMemeWords(memeId);
+            if (!linked || linked.size === 0) continue;
+            let hit = 0;
+            for (const w of words) {
+                if (linked.has(w)) hit += 1;
+            }
+            coverage += hit / Math.max(1, linked.size);
+        }
+        return coverage / Math.max(1, seeds.size);
+    }
+
+    async attackAndDefend(samples) {
+        const bench = samples.slice(0, this.benchLimit);
+        const rounds = [];
+        // 攻击阶段
+        for (let r = 0; r < this.attackRounds; r++) {
+            const results = [];
+            for (const s of bench) {
+                const advs = this._generateAdversaries(s);
+                for (const a of advs) {
+                    results.push(await this._probe(a));
+                }
+            }
+            rounds.push({ phase: 'attack', results });
+        }
+        // 防御阶段：对低质量回复进行图修复（增加边权或添加桥接）
+        const fixes = [];
+        for (let d = 0; d < this.defenseRounds; d++) {
+            for (const s of bench) {
+                const res = await this._probe(s);
+                if (res.quality < 0.25) {
+                    const words = tokenize(res.reply).slice(0, 12);
+                    const seeds = this.pool.getActive().runtime.mapWordsToMemes(words);
+                    const ids = Array.from(seeds.keys());
+                    for (let i = 0; i < ids.length - 1; i++) {
+                        this.pool.getActive().runtime.graph.link(ids[i], ids[i + 1], 0.5, 0);
+                    }
+                    fixes.push({ sample: s, addedEdges: Math.max(0, ids.length - 1) });
+                }
+            }
+            rounds.push({ phase: 'defense', fixes });
+        }
+        const summary = this._summarize(rounds);
+        this.history.push({ ts: Date.now(), rounds, summary });
+        return { ok: true, summary };
+    }
+
+    _summarize(rounds) {
+        const stats = { attack: { n: 0, avgQuality: 0 }, defense: { fixes: 0 } };
+        let qsum = 0;
+        let qcnt = 0;
+        for (const r of rounds) {
+            if (r.phase === 'attack') {
+                stats.attack.n += r.results.length;
+                for (const item of r.results) {
+                    qsum += item.quality;
+                    qcnt += 1;
+                }
+            } else if (r.phase === 'defense') {
+                stats.defense.fixes += (r.fixes || []).length;
+            }
+        }
+        stats.attack.avgQuality = qcnt ? (qsum / qcnt) : 0;
+        return stats;
+    }
+
+    latest() { return this.history[this.history.length - 1] || null; }
+}
+
+
+class GatewayServer {
+    constructor(pool, shardManager, snapshotManager, rotation, redisSync, study, sparkArray, learners = {}) {
+        this.pool = pool;
+        this.shards = shardManager;
+        this.snapshots = snapshotManager;
+        this.rotation = rotation;
+        this.redisSync = redisSync;
+        this.study = study;
+        this.spark = sparkArray || new SparkArray(pool, shardManager);
+        this.rl = learners.rl || new ReinforcementLearner(this.pool, {});
+        this.adv = learners.adv || new AdversarialLearner(this.pool, {});
+        this.rlDisabled = false;
+        this.advDisabled = false;
+        this.dialogLearningEnabled = true;
+        this.dialogCounters = { total: 0, lastRL: 0, lastADV: 0 };
+        this.dialogThresholds = { rlEvery: 20, advEvery: 30 };
+        // 创建并启动 MemeBarrier（可通过 CLI 关闭）
+        if (!CONFIG.disableBarrier) {
+            try {
+                this.barrier = new MemeBarrier(this.pool.getActive().runtime, {
+                    maliciousThreshold: modelDefaults.maliciousThreshold
+                });
+                this.barrier.start();
+            } catch (e) {
+                console.warn('[Gateway] MemeBarrier init failed:', e.message);
+            }
+        } else {
+            this.barrier = null;
+            console.log('[Gateway] MemeBarrier disabled by config');
+        }
+        this.app = express();
+        this.app.use(bodyParser.json({ limit: '10mb' }));
+        this.app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
+
+        // Auth: protect /api/* by default (can be disabled via env for dev).
+        this.auth = {
+            enabled: String(process.env.AI_AUTH_ENABLED || 'true').toLowerCase() !== 'false',
+            jwtSecret: String(process.env.AI_AUTH_JWT_SECRET || process.env.AUTH_JWT_SECRET || 'dev-secret-change-me'),
+            publicPaths: new Set([
+                '/api/system/status'
+            ])
+        };
+        this._setupAuthMiddleware();
+        // Compatibility shim: Express 4.0 relies on deprecated res._headers (removed in modern Node).
+        // We monkey-patch setHeader to maintain res._headers and res.headers so fresh(req,resHeaders) works.
+        this.app.use((req, res, next) => {
+            if (!res._headers) {
+                res._headers = {}; // initialize
+            }
+            // Maintain a plain object reference for (res._headers || res.headers) legacy check.
+            res.headers = res._headers;
+            const originalSetHeader = res.setHeader;
+            if (!res.__patchedSetHeader) {
+                res.setHeader = function(name, value) {
+                    originalSetHeader.call(this, name, value);
+                    const lower = String(name).toLowerCase();
+                    if (!this._headers) {
+                        this._headers = {};
+                    }
+                    this._headers[lower] = value;
+                    this.headers = this._headers;
+                };
+                res.__patchedSetHeader = true;
+            }
+            next();
+        });
+        // 根据 CLI 关闭学习模块（但允许运行时重新开启）
+        this.rlDisabled = this.rlDisabled || CONFIG.disableLearning || CONFIG.disableRL;
+        this.advDisabled = this.advDisabled || CONFIG.disableLearning || CONFIG.disableADV;
+        // 如果 CLI 禁用学习，则默认关闭对话触发（可运行时打开）
+        this.dialogLearningEnabled = !(CONFIG.disableLearning === true);
+        this._setupRoutes();
+    }
+
+    _setupAuthMiddleware() {
+        let jwt;
+        try {
+            jwt = require('jsonwebtoken');
+        } catch (_e) {
+            jwt = null;
+        }
+
+        const parseBearer = (req) => {
+            const h = req.headers.authorization || '';
+            const m = /^Bearer\s+(.+)$/i.exec(String(h));
+            return m ? m[1] : '';
+        };
+
+        this.app.use((req, res, next) => {
+            if (!this.auth.enabled) return next();
+            if (req.method === 'OPTIONS') return next();
+            if (!req.path.startsWith('/api/')) return next();
+            if (this.auth.publicPaths.has(req.path)) return next();
+
+            const token = parseBearer(req);
+            if (!token) {
+                res.status(401).json({ ok: false, error: 'unauthorized' });
+                return;
+            }
+            if (!jwt) {
+                res.status(500).json({ ok: false, error: 'auth-lib-missing' });
+                return;
+            }
+            try {
+                const payload = jwt.verify(token, this.auth.jwtSecret);
+                req.user = payload;
+                return next();
+            } catch (e) {
+                res.status(401).json({ ok: false, error: 'invalid-token', message: e.message });
+            }
         });
+    }
+
+    _getRuntimeFeatureState() {
+        return {
+            memebarrier: {
+                enabled: Boolean(this.barrier && this.barrier.running),
+                available: !CONFIG.disableBarrier,
+                threshold: this.barrier ? this.barrier.maliciousThreshold : modelDefaults.maliciousThreshold
+            },
+            learning: {
+                // learning 是总开关：关闭时同时禁用 RL/ADV 的自动触发与端点
+                enabled: !(this.rlDisabled && this.advDisabled),
+                cliDisabled: Boolean(CONFIG.disableLearning)
+            },
+            rl: {
+                enabled: !this.rlDisabled,
+                cliDisabled: Boolean(CONFIG.disableLearning || CONFIG.disableRL)
+            },
+            adv: {
+                enabled: !this.advDisabled,
+                cliDisabled: Boolean(CONFIG.disableLearning || CONFIG.disableADV)
+            },
+            dialogLearning: {
+                enabled: Boolean(this.dialogLearningEnabled)
+            },
+            dialogThresholds: { ...this.dialogThresholds },
+            dialogCounters: { ...this.dialogCounters }
+        };
+    }
+
+    _applyRuntimeFeaturePatch(patch = {}) {
+        const out = { applied: {}, warnings: [] };
+        // MemeBarrier
+        if (typeof patch.memebarrierEnabled === 'boolean') {
+            if (patch.memebarrierEnabled) {
+                if (!this.barrier) {
+                    this.barrier = new MemeBarrier(this.pool.getActive().runtime, {
+                        maliciousThreshold: modelDefaults.maliciousThreshold
+                    });
+                }
+                this.barrier.start();
+            } else {
+                if (this.barrier) this.barrier.stop();
+            }
+            out.applied.memebarrierEnabled = patch.memebarrierEnabled;
+        }
+        if (typeof patch.maliciousThreshold === 'number' && Number.isFinite(patch.maliciousThreshold)) {
+            if (!this.barrier) {
+                this.barrier = new MemeBarrier(this.pool.getActive().runtime, {
+                    maliciousThreshold: patch.maliciousThreshold
+                });
+            }
+            this.barrier.maliciousThreshold = patch.maliciousThreshold;
+            out.applied.maliciousThreshold = patch.maliciousThreshold;
+        }
+
+        // Learning/RL/ADV
+        // 注意：CLI disable 表示“启动默认禁用”，但允许运行时打开；若你希望完全锁死，可再加一个 CONFIG.lockRuntimeToggles。
+        if (typeof patch.learningEnabled === 'boolean') {
+            if (patch.learningEnabled) {
+                // 仅解除总禁用：不强行打开 RL/ADV，由各自开关决定
+                // 如果之前是因为 disableLearning 置为 true，这里也允许解除。
+                if (CONFIG.disableLearning) {
+                    out.warnings.push('learning was CLI-disabled; runtime override enabled');
+                }
+                // 不做事，交给 rlEnabled/advEnabled 或保持现状
+            } else {
+                this.rlDisabled = true;
+                this.advDisabled = true;
+                this.dialogLearningEnabled = false;
+            }
+            out.applied.learningEnabled = patch.learningEnabled;
+        }
+        if (typeof patch.rlEnabled === 'boolean') {
+            if (patch.rlEnabled) {
+                if (CONFIG.disableLearning || CONFIG.disableRL) {
+                    out.warnings.push('rl was CLI-disabled; runtime override enabled');
+                }
+                this.rlDisabled = false;
+            } else {
+                this.rlDisabled = true;
+            }
+            out.applied.rlEnabled = patch.rlEnabled;
+        }
+        if (typeof patch.advEnabled === 'boolean') {
+            if (patch.advEnabled) {
+                if (CONFIG.disableLearning || CONFIG.disableADV) {
+                    out.warnings.push('adv was CLI-disabled; runtime override enabled');
+                }
+                this.advDisabled = false;
+            } else {
+                this.advDisabled = true;
+            }
+            out.applied.advEnabled = patch.advEnabled;
+        }
+
+        if (typeof patch.dialogLearningEnabled === 'boolean') {
+            this.dialogLearningEnabled = patch.dialogLearningEnabled;
+            out.applied.dialogLearningEnabled = patch.dialogLearningEnabled;
+        }
+
+        // Dialog thresholds
+        if (typeof patch.rlEvery === 'number' && Number.isFinite(patch.rlEvery) && patch.rlEvery > 0) {
+            this.dialogThresholds.rlEvery = patch.rlEvery;
+            out.applied.rlEvery = patch.rlEvery;
+        }
+        if (typeof patch.advEvery === 'number' && Number.isFinite(patch.advEvery) && patch.advEvery > 0) {
+            this.dialogThresholds.advEvery = patch.advEvery;
+            out.applied.advEvery = patch.advEvery;
+        }
+        return out;
+    }
+
+    _setupRoutes() {
+        // Main AI 进程不再托管前端；根路径返回提示。
+        this.app.get('/', (req, res) => {
+            res.status(404).send('UI moved to auth_frontend_server.cjs (default :5081)');
+        });
+
+        // 前端托管已迁移到独立进程（auth_frontend_server.cjs）。
+        // 这里保留纯 API（/api、/robots 等）以减少主 AI 进程职责。
         this.app.post('/api/chat', async (req, res) => {
             try {
                 const controller = this.pool.getActive();
                 const result = await controller.respond(req.body || {});
                 res.json({ ok: true, result });
+                this._onDialogCompleted(result, req.body || {});
             } catch (err) {
                 res.status(500).json({ ok: false, error: err.message });
             }
         });
+
+        // 运行时配置/开关（React 控制台使用）
+        this.app.get('/api/runtime/features', (req, res) => {
+            res.json({ ok: true, features: this._getRuntimeFeatureState() });
+        });
+        this.app.patch('/api/runtime/features', (req, res) => {
+            try {
+                const result = this._applyRuntimeFeaturePatch(req.body || {});
+                res.json({ ok: true, result, features: this._getRuntimeFeatureState() });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        this.app.get('/api/study/status', (req, res) => {
+            const q = this.study?.queue?.length ?? 0;
+            res.json({
+                ok: true,
+                running: Boolean(this.study?.running),
+                queue: q,
+                metrics: this.study?.metrics || null
+            });
+        });
+
+        this.app.post('/api/learn/dialog/reset', (req, res) => {
+            this.dialogCounters = { total: 0, lastRL: 0, lastADV: 0 };
+            res.json({ ok: true, dialogCounters: this.dialogCounters });
+        });
         this.app.post('/api/array/chat', async (req, res) => {
             try {
                 const payload = req.body || {};
@@ -2072,8 +3759,59 @@ class GatewayServer {
                     res.status(400).json({ ok: false, error: 'text required' });
                     return;
                 }
-                const result = await this.spark.dispatch(payload, payload.options || {});
+        // Reinforcement Learning endpoints
+        this.app.post('/api/learn/reinforce', async (req, res) => {
+            try {
+                if (this.rlDisabled) {
+                    res.status(503).json({ ok: false, error: 'rl-disabled' });
+                    return;
+                }
+                const cycles = Number(req.body?.cycles ?? 3) || 3;
+                const out = await this.rl.learn(cycles);
+                res.json({ ok: true, result: out });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.get('/api/learn/reinforce/latest', (req, res) => {
+            res.json({ ok: true, latest: this.rl.latest() });
+        });
+        // Adversarial Learning endpoints
+        this.app.post('/api/learn/adversarial', async (req, res) => {
+            try {
+                if (this.advDisabled) {
+                    res.status(503).json({ ok: false, error: 'adv-disabled' });
+                    return;
+                }
+                const samples = Array.isArray(req.body?.samples) ? req.body.samples : [];
+                if (!samples.length) {
+                    res.status(400).json({ ok: false, error: 'samples required' });
+                    return;
+                }
+                const out = await this.adv.attackAndDefend(samples);
+                res.json({ ok: true, result: out });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.get('/api/learn/adversarial/latest', (req, res) => {
+            res.json({ ok: true, latest: this.adv.latest() });
+        });
+        this.app.post('/api/learn/thresholds', (req, res) => {
+            const { rlEvery, advEvery } = req.body || {};
+            if (Number.isFinite(rlEvery) && rlEvery > 0) this.dialogThresholds.rlEvery = rlEvery;
+            if (Number.isFinite(advEvery) && advEvery > 0) this.dialogThresholds.advEvery = advEvery;
+            res.json({ ok: true, thresholds: this.dialogThresholds });
+        });
+                const opts = payload.options || {};
+                const bigRounds = Number(opts.bigRounds ?? opts.bigSparkRounds ?? 1) || 1;
+                const result = bigRounds > 1
+                    ? await this.spark.dispatchBig(payload, opts)
+                    : await this.spark.dispatch(payload, opts);
                 res.json({ ok: true, result });
+                const agg = result?.aggregate;
+                const dialog = agg ? { reply: agg.reply, latency: agg.latency, sessionId: agg.sessionId, seeds: [] } : null;
+                this._onDialogCompleted(dialog, payload || {});
             } catch (err) {
                 res.status(500).json({ ok: false, error: err.message });
             }
@@ -2091,7 +3829,7 @@ class GatewayServer {
             res.json({ ok: true, params: this.pool.getActive().runtime.cloneParams() });
         });
         this.app.get('/api/array/layers', (req, res) => {
-            res.json({ ok: true, layers: this.spark.getLayers(), history: this.spark.history.slice(-20) });
+            res.json({ ok: true, layers: this.spark.getLayers(), history: (this.spark.history || []).slice(-20) });
         });
         this.app.post('/api/array/layers', (req, res) => {
             try {
@@ -2102,7 +3840,7 @@ class GatewayServer {
             }
         });
         this.app.get('/api/array/history', (req, res) => {
-            res.json({ ok: true, history: this.spark.history.slice(-20) });
+            res.json({ ok: true, history: (this.spark.history || []).slice(-20) });
         });
         this.app.get('/api/snapshots', (req, res) => {
             res.json({ ok: true, list: this.snapshots.list() });
@@ -2132,10 +3870,53 @@ class GatewayServer {
                 load: os.loadavg(),
                 memory: process.memoryUsage(),
                 controllers: this.pool.listMetrics(),
+                groups: typeof this.pool.listGroupIds === 'function'
+                    ? this.pool.listGroupIds().map((gid) => ({ gid, controllers: this.pool.listControllersInGroup(gid) }))
+                    : [],
                 rotation: { running: this.rotation.running, cycleMs: this.rotation.cycleMs },
                 redis: { channel: this.redisSync.channel }
             });
         });
+
+        // 只读系统配置（组数/组大小等；修改需要重启进程）
+        this.app.get('/api/system/config', (req, res) => {
+            res.json({
+                ok: true,
+                config: {
+                    groupCount: CONFIG.groupCount,
+                    groupSize: CONFIG.groupSize,
+                    groupIds: typeof this.pool.listGroupIds === 'function' ? this.pool.listGroupIds() : [],
+                    gatewayHost: CONFIG.gatewayHost,
+                    portGateway: CONFIG.portGateway,
+                    portStudy: CONFIG.portStudy
+                }
+            });
+        });
+
+        // 组信息：用于前端展示与按组操作
+        this.app.get('/api/groups', (req, res) => {
+            const groupIds = typeof this.pool.listGroupIds === 'function' ? this.pool.listGroupIds() : [];
+            res.json({
+                ok: true,
+                groupSize: CONFIG.groupSize,
+                groupCount: CONFIG.groupCount,
+                groups: groupIds.map((gid) => ({ gid, controllers: this.pool.listControllersInGroup(gid) }))
+            });
+        });
+
+        this.app.get('/api/groups/:gid/metrics', (req, res) => {
+            const gid = String(req.params.gid || '').trim();
+            const list = typeof this.pool.listControllersInGroup === 'function' ? this.pool.listControllersInGroup(gid) : [];
+            if (!list.length) {
+                res.status(404).json({ ok: false, error: 'group-not-found' });
+                return;
+            }
+            const metrics = list
+                .map((name) => this.pool.getByName(name))
+                .filter(Boolean)
+                .map((ctrl) => ctrl.metrics());
+            res.json({ ok: true, gid, controllers: metrics });
+        });
         this.app.get('/api/system/ai/:name', (req, res) => {
             const ctrl = this.pool.getByName(req.params.name);
             if (!ctrl) {
@@ -2193,9 +3974,288 @@ class GatewayServer {
                 res.status(500).json({ ok: false, error: err.message });
             }
         });
+
+        // 站内递归抓取：同域 HTML + 可选 PDF 文本抽取（仅用于你有授权的网站）
+        this.app.post('/api/corpus/crawl', async (req, res) => {
+            try {
+                const { startUrl, options, ingest, groupId, source } = req.body || {};
+                const url = String(startUrl || '').trim();
+                if (!url) {
+                    res.status(400).json({ ok: false, error: 'startUrl required' });
+                    return;
+                }
+                const runtime = this.pool.getActive().runtime;
+                const result = await runtime.onlineLookup(url, { mode: 'crawl', crawl: { startUrl: url, ...(options || {}) } });
+
+                let ingested = null;
+                if (ingest) {
+                    const docs = (result?.pages || [])
+                        .filter((p) => p && p.text && String(p.text).trim())
+                        .map((p) => ({
+                            text: String(p.text),
+                            source: String(source || p.url || 'crawl')
+                        }));
+                    if (docs.length) {
+                        const details = [];
+                        for (const doc of docs) {
+                            const r = groupId ? await this.pool.ingestDocumentToGroup(String(groupId), doc) : await this.pool.ingestDocument(doc);
+                            details.push({ source: doc.source, result: r });
+                        }
+                        ingested = { docs: docs.length, details: details.slice(0, 20) };
+                    } else {
+                        ingested = { docs: 0 };
+                    }
+                }
+
+                res.json({ ok: true, result, ingested });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        // 在线搜索配置（运行时开关 + endpoint 库）
+        this.app.get('/api/search/config', (req, res) => {
+            try {
+                const runtime = this.pool.getActive().runtime;
+                res.json({ ok: true, config: runtime.getSearchConfig() });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.put('/api/search/config', (req, res) => {
+            try {
+                const runtime = this.pool.getActive().runtime;
+                const next = runtime.setSearchConfig(req.body || {});
+                res.json({ ok: true, config: next });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.post('/api/search/endpoints/add', (req, res) => {
+            try {
+                const url = String(req.body?.url || '').trim();
+                if (!url) {
+                    res.status(400).json({ ok: false, error: 'url required' });
+                    return;
+                }
+                const runtime = this.pool.getActive().runtime;
+                const cfg = runtime.getSearchConfig();
+                const endpoints = Array.from(new Set([...(cfg.endpoints || []), url]));
+                const next = runtime.setSearchConfig({ endpoints });
+                res.json({ ok: true, config: next });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.post('/api/search/endpoints/remove', (req, res) => {
+            try {
+                const url = String(req.body?.url || '').trim();
+                if (!url) {
+                    res.status(400).json({ ok: false, error: 'url required' });
+                    return;
+                }
+                const runtime = this.pool.getActive().runtime;
+                const cfg = runtime.getSearchConfig();
+                const endpoints = (cfg.endpoints || []).filter((x) => x !== url);
+                const nextPatch = { endpoints };
+                if (cfg.active === url) {
+                    nextPatch.active = endpoints[0] || '';
+                }
+                const next = runtime.setSearchConfig(nextPatch);
+                res.json({ ok: true, config: next });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        // Tests 用例：运行时新增/列出/刷新（用于 RL 的 testsDir 词表刷新）
+        this.app.get('/api/tests/list', (req, res) => {
+            try {
+                const runtime = this.pool.getActive().runtime;
+                const testsDir = runtime?.config?.testsDir || path.join(__dirname, 'tests');
+                let files = [];
+                if (fs.existsSync(testsDir)) {
+                    files = fs.readdirSync(testsDir)
+                        .filter((f) => /\.txt$/i.test(f))
+                        .sort();
+                }
+                res.json({ ok: true, directory: testsDir, files });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        this.app.post('/api/tests/case', (req, res) => {
+            try {
+                const nameRaw = String(req.body?.name || '').trim();
+                const content = String(req.body?.content || '');
+                if (!nameRaw) {
+                    res.status(400).json({ ok: false, error: 'name required' });
+                    return;
+                }
+                const safeName = nameRaw.replace(/[^a-zA-Z0-9._-]+/g, '_');
+                const filename = safeName.toLowerCase().endsWith('.txt') ? safeName : `${safeName}.txt`;
+                const runtime = this.pool.getActive().runtime;
+                const testsDir = runtime?.config?.testsDir || path.join(__dirname, 'tests');
+                fs.mkdirSync(testsDir, { recursive: true });
+                const filePath = path.join(testsDir, filename);
+                fs.writeFileSync(filePath, content, 'utf8');
+                res.json({ ok: true, file: filename, path: filePath });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        this.app.post('/api/tests/refresh', async (req, res) => {
+            try {
+                // 目标：让 RL 模块在运行时读取最新 tests 词表
+                // 做法：调用 rl.refreshTests()（若存在），否则尝试重建 RL 实例
+                const testsDir = this.pool.getActive().runtime?.config?.testsDir || path.join(__dirname, 'tests');
+                let refreshed = false;
+                if (this.rl && typeof this.rl.refreshTests === 'function') {
+                    await Promise.resolve(this.rl.refreshTests({ testsDir }));
+                    refreshed = true;
+                } else if (this.rl && typeof this.rl.setTestsDir === 'function') {
+                    await Promise.resolve(this.rl.setTestsDir(testsDir));
+                    refreshed = true;
+                } else {
+                    // 最保守方案：替换 RL learner（不影响主 runtime）
+                    this.rl = new ReinforcementLearner(this.pool, { testsDir });
+                    // 如果当前是启用状态，保持启用
+                    refreshed = true;
+                }
+                res.json({ ok: true, refreshed, testsDir });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        // 反序列化导出：将当前图窗口反序列化为 Graph 并写入文件
+        this.app.post('/api/export/graph', (req, res) => {
+            try {
+                const { seeds, radius, file } = req.body || {};
+                const runtime = this.pool.getActive().runtime;
+                const outFile = runtime.exportGraphToFile({ seeds, radius, file });
+                // 返回文件内容，便于直接复制到 Go 侧
+                const content = fs.readFileSync(outFile, 'utf8');
+                res.json({ ok: true, file: path.basename(outFile), path: outFile, content });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        // 按组导出图：用于 BigSparkArray 时代分别取各工作组的图结构
+        this.app.post('/api/export/graph/group', (req, res) => {
+            try {
+                const { groupId, seeds, radius, file } = req.body || {};
+                const gid = String(groupId || '').trim();
+                if (!gid) {
+                    res.status(400).json({ ok: false, error: 'groupId required' });
+                    return;
+                }
+                const list = typeof this.pool.listControllersInGroup === 'function' ? this.pool.listControllersInGroup(gid) : [];
+                if (!list.length) {
+                    res.status(404).json({ ok: false, error: 'group-not-found' });
+                    return;
+                }
+                const ctrl = this.pool.getByName(list[0]);
+                if (!ctrl) {
+                    res.status(404).json({ ok: false, error: 'controller-not-found' });
+                    return;
+                }
+                const runtime = ctrl.runtime;
+                const outFile = runtime.exportGraphToFile({ seeds, radius, file });
+                const content = fs.readFileSync(outFile, 'utf8');
+                res.json({ ok: true, groupId: gid, file: path.basename(outFile), path: outFile, content });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+
+        // Robots：运行时触发重训（重新 ingest robots 语料，并可选 enqueueStudy）
+        this.app.post('/api/robots/retrain', async (req, res) => {
+            try {
+                const options = req.body || {};
+                const runtime = this.pool.getActive().runtime;
+                const docs = runtime.collectRobotsDocuments({
+                    limit: options.limit,
+                    offset: options.offset,
+                    shuffle: Boolean(options.shuffle),
+                    files: Array.isArray(options.files)
+                        ? options.files
+                        : (typeof options.files === 'string' && options.files.trim() ? [options.files.trim()] : undefined)
+                });
+                if (!docs.length) {
+                    res.status(404).json({ ok: false, error: 'no-documents' });
+                    return;
+                }
+                let ingested = 0;
+                let memes = 0;
+                let edges = 0;
+                let failedControllers = 0;
+                const groups = typeof this.pool.listGroupIds === 'function' ? this.pool.listGroupIds() : [];
+                for (const doc of docs) {
+                    // 默认按组分片：每个工作组 ingest 不同语料
+                    const key = String(doc?.source || doc?.file || doc?.id || '') + '|' + String(doc?.text || '').slice(0, 256);
+                    const gi = groups.length ? (hashStrSimple(key) % groups.length) : 0;
+                    const targetGroup = groups[gi] || groups[0];
+                    const results = targetGroup ? await this.pool.ingestDocumentToGroup(targetGroup, doc) : await this.pool.ingestDocument(doc);
+                    ingested += 1;
+                    const list = Array.isArray(results) ? results : [results];
+                    for (const item of list) {
+                        if (item && item.ok !== false) {
+                            memes += Number(item.memes || 0) || 0;
+                            edges += Number(item.edges || 0) || 0;
+                        } else {
+                            failedControllers += 1;
+                        }
+                    }
+                    if (options.enqueueStudy && this.study) {
+                        this.study.enqueueDocument(doc);
+                    }
+                }
+                res.json({ ok: true, ingested, memes, edges, failedControllers });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
         this.app.get('/robots/list', (req, res) => {
             try {
                 const runtime = this.pool.getActive().runtime;
+        // MemeBarrier 控制与统计端点
+        this.app.post('/api/memebarrier/start', (req, res) => {
+            try {
+                if (!this.barrier) {
+                    this.barrier = new MemeBarrier(this.pool.getActive().runtime, {
+                        maliciousThreshold: (req.body?.maliciousThreshold ?? modelDefaults.maliciousThreshold)
+                    });
+                }
+                if (req.body && typeof req.body.maliciousThreshold === 'number') {
+                    this.barrier.maliciousThreshold = req.body.maliciousThreshold;
+                }
+                this.barrier.start();
+                res.json({ ok: true, running: true, threshold: this.barrier.maliciousThreshold });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.post('/api/memebarrier/stop', (req, res) => {
+            try {
+                if (this.barrier) {
+                    this.barrier.stop();
+                }
+                res.json({ ok: true, running: false });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
+        this.app.get('/api/memebarrier/stats', (req, res) => {
+            try {
+                const stats = this.barrier ? this.barrier.getStats() : null;
+                res.json({ ok: true, stats });
+            } catch (err) {
+                res.status(500).json({ ok: false, error: err.message });
+            }
+        });
                 res.json({
                     ok: true,
                     directory: runtime.config?.robotsDir,
@@ -2223,9 +4283,14 @@ class GatewayServer {
                     return;
                 }
                 const summary = [];
+                const groups = typeof this.pool.listGroupIds === 'function' ? this.pool.listGroupIds() : [];
                 for (const doc of docs) {
-                    const results = await this.pool.ingestDocument(doc);
-                    const aggregated = results.reduce(
+                    const key = String(doc?.source || doc?.file || doc?.id || '') + '|' + String(doc?.text || '').slice(0, 256);
+                    const gi = groups.length ? (hashStrSimple(key) % groups.length) : 0;
+                    const targetGroup = groups[gi] || groups[0];
+                    const results = targetGroup ? await this.pool.ingestDocumentToGroup(targetGroup, doc) : await this.pool.ingestDocument(doc);
+                    const list = Array.isArray(results) ? results : [results];
+                    const aggregated = list.reduce(
                         (acc, item) => {
                             if (item && item.ok !== false) {
                                 const memes = Number(item.memes || 0);
@@ -2264,9 +4329,35 @@ class GatewayServer {
         });
     }
 
-    listen(port) {
-        this.app.listen(port, () => {
-            console.log(`[Gateway] listening on ${port}`);
+    _onDialogCompleted(result, payload) {
+        try {
+            this.dialogCounters.total += 1;
+            const total = this.dialogCounters.total;
+            if (!this.dialogLearningEnabled) {
+                return;
+            }
+            if (!this.rlDisabled && (total - this.dialogCounters.lastRL >= this.dialogThresholds.rlEvery)) {
+                this.dialogCounters.lastRL = total;
+                Promise.resolve().then(() => this.rl.learn(1)).catch((e) => console.warn('[Learn] RL trigger failed:', e.message));
+            }
+            if (!this.advDisabled && (total - this.dialogCounters.lastADV >= this.dialogThresholds.advEvery)) {
+                this.dialogCounters.lastADV = total;
+                const text = typeof payload?.text === 'string' ? payload.text : (Array.isArray(payload?.tokens) ? payload.tokens.join(' ') : '');
+                const samples = [];
+                if (text && text.trim()) samples.push(text.trim());
+                if (result?.reply && typeof result.reply === 'string') samples.push(result.reply);
+                if (samples.length) {
+                    Promise.resolve().then(() => this.adv.attackAndDefend(samples)).catch((e) => console.warn('[Learn] ADV trigger failed:', e.message));
+                }
+            }
+        } catch (e) {
+            console.warn('[Learn] dialog hook error:', e.message);
+        }
+    }
+
+    listen(port, host = '127.0.0.1') {
+        this.app.listen(port, host, () => {
+            console.log(`[Gateway] listening on ${host}:${port}`);
         });
     }
 }
@@ -2289,8 +4380,24 @@ const bootstrap = async () => {
     study.start();
     const snapshots = new SnapshotManager(pool.getActive().runtime, CONFIG.snapshotDir);
     const shards = new ShardManager(pool);
-    const spark = new SparkArray(pool, shards);
-    if (CONFIG.robotsAutoload && CONFIG.robotsWarmupLimit > 0) {
+    const spark = new BigSparkArray(pool, shards, { groupIds: pool.listGroupIds() });
+    // Try auto-restore latest snapshot to skip warmup/pretraining
+    let __restoredFromSnapshot = false;
+    try {
+        const list = snapshots.list().sort((a, b) => b.localeCompare(a));
+        if (list.length > 0) {
+            await snapshots.restore(list[0]);
+            __restoredFromSnapshot = true;
+            console.log(`[Bootstrap] Restored latest snapshot: ${list[0]}`);
+            // Keep standby/validation in sync with serving
+            const snap = pool.getActive().snapshot();
+            await pool.standby.applySnapshot(snap);
+            await pool.validation.applySnapshot(snap);
+        }
+    } catch (err) {
+        console.warn('[Bootstrap] Snapshot restore skipped:', err.message);
+    }
+    if (CONFIG.robotsAutoload && CONFIG.robotsWarmupLimit > 0 && !__restoredFromSnapshot) {
         try {
             const preloadDocs = pool.getActive().runtime.collectRobotsDocuments({
                 limit: CONFIG.robotsWarmupLimit,
@@ -2298,8 +4405,13 @@ const bootstrap = async () => {
             });
             if (preloadDocs.length) {
                 console.log(`[Bootstrap] Preloading ${preloadDocs.length} robots documents...`);
-                for (const doc of preloadDocs) {
-                    await pool.ingestDocument(doc);
+                const groups = pool.listGroupIds();
+                for (let i = 0; i < preloadDocs.length; i++) {
+                    const doc = preloadDocs[i];
+                    const key = String(doc?.source || doc?.file || doc?.id || '') + '|' + String(doc?.text || '').slice(0, 256);
+                    const idx = groups.length ? (hashStrSimple(key) % groups.length) : 0;
+                    const targetGroup = groups[idx] || groups[0] || 'G1';
+                    await pool.ingestDocumentToGroup(targetGroup, { ...doc, source: doc?.source || `robots:${doc?.file || 'unknown'}` });
                 }
                 console.log('[Bootstrap] Robots corpus preload completed.');
             } else {
@@ -2309,10 +4421,74 @@ const bootstrap = async () => {
             console.warn('[Bootstrap] Robots preload skipped:', err.message);
         }
     }
-    const gateway = new GatewayServer(pool, shards, snapshots, rotation, redisSync, study, spark);
-    gateway.listen(CONFIG.portGateway);
-    process.on('SIGINT', () => {
-        console.log('Received SIGINT, shutting down.');
+
+    // 额外：将 tests 目录用例按哈希分片到不同 AI，形成差异化“训练集”
+    try {
+        const testsDir = path.join(__dirname, 'tests');
+        if (fs.existsSync(testsDir)) {
+            const files = fs.readdirSync(testsDir).filter((f) => /\.txt$/i.test(f));
+            if (files.length) {
+                const groups = pool.listGroupIds();
+                for (const f of files) {
+                    const full = path.join(testsDir, f);
+                    const text = fs.readFileSync(full, 'utf8');
+                    const key = `tests:${f}`;
+                    const idx = groups.length ? (hashStrSimple(key) % groups.length) : 0;
+                    const targetGroup = groups[idx] || groups[0] || 'G1';
+                    await pool.ingestDocumentToGroup(targetGroup, { text, source: key });
+                }
+                console.log(`[Bootstrap] Sharded tests corpus into ${groups.length} groups.`);
+            }
+        }
+    } catch (err) {
+        console.warn('[Bootstrap] Tests sharded preload skipped:', err.message);
+    }
+    // 初始化学习模块
+    const rl = new ReinforcementLearner(pool, { testsDir: path.join(__dirname, 'tests') });
+    const adv = new AdversarialLearner(pool, {});
+    const gateway = new GatewayServer(pool, shards, snapshots, rotation, redisSync, study, spark, { rl, adv });
+    gateway.listen(CONFIG.portGateway, CONFIG.gatewayHost);
+    // 轻量启动：尝试执行一次强化学习与对抗学习以预热
+    (async () => {
+        // RL 预热（可通过 CLI 关闭）
+        if (!CONFIG.disableLearning && !CONFIG.disableRL) {
+            try {
+                await rl.learn(1);
+            } catch (e) {
+                console.warn('[Bootstrap] RL warmup failed:', e.message);
+                // 预热失败后禁用 RL，后续触发与端点均短路
+                try { gateway.rlDisabled = true; } catch (_) {}
+            }
+        } else {
+            try { gateway.rlDisabled = true; } catch (_) {}
+            console.log('[Bootstrap] RL disabled by config');
+        }
+        // ADV 预热（可通过 CLI 关闭）
+        if (!CONFIG.disableLearning && !CONFIG.disableADV) {
+            try {
+                // 从 robots 目录挑选少量样本作为对抗试探
+                const runtime = pool.getActive().runtime;
+                const docs = runtime.collectRobotsDocuments({ limit: 3, shuffle: true });
+                const samples = docs.map(d => d.text).filter(Boolean).slice(0, 3);
+                if (samples.length) {
+                    await adv.attackAndDefend(samples);
+                }
+            } catch (e) {
+                console.warn('[Bootstrap] Adversarial warmup failed:', e.message);
+            }
+        } else {
+            try { gateway.advDisabled = true; } catch (_) {}
+            console.log('[Bootstrap] ADV disabled by config');
+        }
+    })();
+    process.on('SIGINT', async () => {
+        console.log('Received SIGINT, saving snapshot...');
+        try {
+            const file = await snapshots.create('autosave');
+            console.log(`Snapshot saved: ${path.basename(file)}`);
+        } catch (err) {
+            console.warn('[Shutdown] Failed to save snapshot:', err.message);
+        }
         process.exit(0);
     });
 };