079project 8.0.0 → 9.1.0

package/main.cjs

@@ -20,19 +20,111 @@ const safeRequire = (name) => {
     }
 };
 
-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 ?? [];
+// 启动性能优化：重依赖懒加载（避免启动即加载 pdf-parse/cheerio/natural 等）。
+const __lazyModules = new Map();
+const lazyRequire = (name) => {
+    if (__lazyModules.has(name)) {
+        return __lazyModules.get(name);
+    }
+    const mod = safeRequire(name);
+    __lazyModules.set(name, mod);
+    return mod;
+};
+
+const getNatural = () => lazyRequire('natural');
+const getCsvParse = () => lazyRequire('csv-parse/sync');
+const getUmap = () => lazyRequire('umap-js');
+const getAxios = () => lazyRequire('axios');
+const getCheerio = () => lazyRequire('cheerio');
+const getPdfParse = () => lazyRequire('pdf-parse');
+const getMatrix = (() => {
+    let loaded = false;
+    let cached = null;
+    return () => {
+        if (loaded) return cached;
+        loaded = true;
+        const MatrixLib = lazyRequire('ml-matrix');
+        cached = MatrixLib?.Matrix ?? MatrixLib ?? null;
+        return cached;
+    };
+})();
+
+const getStopWords = (() => {
+    let loaded = false;
+    let cached = [];
+    return () => {
+        if (loaded) return cached;
+        loaded = true;
+        const natural = getNatural();
+        const list = natural?.stopwords ?? [];
+        cached = Array.isArray(list) ? list : [];
+        return cached;
+    };
+})();
 const DEFAULT_CHANNEL = process.env.AI_REDIS_CHANNEL || 'AI-model-workspace';
 
+/**
+ * 外参列表（所有“外部可控参数”的入口汇总）
+ *
+ * 1) 启动时参数（CLI flags，形如 --k=v 或 --flag=true）
+ * - --base-dir: 运行时数据目录（默认：./runtime_store；对应 ENV: AI_BASE_DIR）
+ * - --gateway-host: 网关监听 host（默认：127.0.0.1；对应 ENV: AI_GATEWAY_HOST）
+ * - --port: 网关端口（默认：5080；对应 ENV: CONTROLLER_PORT）
+ * - --study-port: study/前端进程端口（默认：5081；对应 ENV: AI_STUDY_PORT）
+ * - --ai-count: 旧版兼容字段；用于 aiCount（默认：7；对应 ENV: AI_COUNT / AI_NUM）
+ * - --group-size: 每个工作组 AI 数量（默认：ai-count；对应 ENV: AI_GROUP_SIZE / GROUP_SIZE）
+ * - --group-count: 组数量（默认：3；对应 ENV: AI_GROUP_COUNT / GROUP_COUNT）
+ * - --spark-num-ai: SparkArray 每组参与汇聚的 AI 数量（默认：group-size；对应 ENV: AI_SPARK_NUM_AI）
+ * - --spark-budget: SparkArray 低精度预算预设（default/low/high 或 JSON；对应 ENV: AI_SPARK_BUDGET）
+ * - --robots-limit: robots 预热/导入条数上限（默认：200；对应 ENV: AI_ROBOTS_LIMIT）
+ * - --redis-url: Redis 连接串（默认：redis://127.0.0.1:6379；对应 ENV: REDIS_URL）
+ * - --channel: Redis pubsub 频道（默认：AI_REDIS_CHANNEL 或 'AI-model-workspace'）
+ * - --snapshot-dir: 快照目录（默认：./snapshots）
+ * - --lmdb-dir: LMDB 根目录（默认：./lmdb；对应 ENV: LMDB_DIR）
+ * - --search-endpoint: 在线检索/搜索服务端点（默认：''；对应 ENV: AI_SEARCH_ENDPOINT）
+ * - --robots-dir: robots 语料目录（默认：./robots；对应 ENV: AI_ROBOTS_DIR）
+ * - --lemma-csv: lemma 词形还原表路径（默认：./lemma.csv；对应 ENV: AI_LEMMA_CSV）
+ * - --robots-autoload: 启动时是否自动加载 robots（默认：true；对应 ENV: AI_ROBOTS_AUTOLOAD）
+ * - --disable-memebarrier: 启动默认禁用 MemeBarrier（对应 ENV: AI_DISABLE_MEMEBARRIER）
+ * - --disable-rl: 启动默认禁用 RL（对应 ENV: AI_DISABLE_RL）
+ * - --disable-adv: 启动默认禁用 ADV（对应 ENV: AI_DISABLE_ADV）
+ * - --disable-learning: 启动默认禁用学习总开关（对应 ENV: AI_DISABLE_LEARNING）
+ * - --export-dir: 图导出目录（默认：./runtime_store；对应 ENV: AI_EXPORT_DIR）
+ *
+ * 2) 环境变量（ENV）
+ * - AI_REDIS_CHANNEL: Redis 频道默认值（被 --channel 覆盖）
+ * - AI_AUTH_ENABLED: 是否启用 /api/* 鉴权（默认：true；'false' 关闭）
+ * - AI_AUTH_JWT_SECRET / AUTH_JWT_SECRET: JWT 密钥（默认：'dev-secret-change-me'）
+ *   - 说明：鉴权默认保护 /api/*，仅 /api/system/status 在 publicPaths 白名单
+ *
+ * 3) 运行时参数（HTTP API，可在不重启的情况下调整）
+ * - POST /api/chat
+ *   - body.text / body.message: 输入文本
+ *   - body.sessionId: 会话 ID（可选；未提供则自动分配）
+ *   - body.tokens / body.words / body.vocab: 直接提供分词（可选；否则对 text 做 tokenize）
+ *
+ * - GET  /api/model/params: 读取当前模型参数
+ * - POST /api/model/params: patch 模型参数（部分字段）
+ * - POST /api/model/params/reset: 重置为 modelDefaults
+ *   - 可 patch 的 key（见下方 modelDefaults）：
+ *     decayFactor, maxMemeWords, minOverlapThreshold, memeNgramMin, memeNgramMax,
+ *     maliciousThreshold, learningIterations, iteration, threshold, decay, decayK,
+ *     maxLen, edgeWeight, activationType, transferType, activationCustom, transferCustom
+ *
+ * - GET  /api/runtime/features: 读取运行时功能开关状态
+ * - PATCH /api/runtime/features: patch 运行时功能开关（字段如下）
+ *   - memebarrierEnabled: boolean
+ *   - maliciousThreshold: number
+ *   - learningEnabled: boolean（总开关；false 会同时关闭 rl/adv/dialogLearning）
+ *   - rlEnabled / advEnabled: boolean
+ *   - dialogLearningEnabled: boolean
+ *   - rlEvery / advEvery: number（对话触发学习的阈值）
+ *   - 注意：CLI 的 disable* 表示“启动默认禁用”，运行时仍允许 override（会返回 warnings）
+ *
+ * - POST /api/learn/thresholds: { rlEvery, advEvery }
+ * - POST /api/learn/reinforce: { cycles }（默认：3）
+ */
+
 const ensureDir = (dir) => {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
@@ -60,8 +152,16 @@ const CONFIG = (() => {
         return !(normalized === '0' || normalized === 'false' || normalized === 'off' || normalized === 'no');
     };
     const robotsLimitRaw = args['robots-limit'] || process.env.AI_ROBOTS_LIMIT || 200;
+    const robotsChunkMinRaw = args['robots-chunk-min'] || process.env.AI_ROBOTS_CHUNK_MIN || 3;
+    const robotsChunkMaxRaw = args['robots-chunk-max'] || process.env.AI_ROBOTS_CHUNK_MAX || 20;
+    const lmdbMapMbRaw = args['lmdb-map-mb'] || process.env.AI_LMDB_MAP_MB || 512;
+    const kvmCacheMaxRaw = args['kvm-cache-max'] || process.env.AI_KVM_CACHE_MAX || 50_000;
+    const lemmaMaxMbRaw = args['lemma-max-mb'] || process.env.AI_LEMMA_MAX_MB || 64;
     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;
+    const groupSizeRaw = args['group-size'] || process.env.AI_GROUP_SIZE || process.env.GROUP_SIZE || aiCountRaw;
+    const sparkNumAiRaw = args['spark-num-ai'] || process.env.AI_SPARK_NUM_AI || groupSizeRaw;
+    const sparkBudgetRaw = args['spark-budget'] || process.env.AI_SPARK_BUDGET || 'default';
     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'),
@@ -69,7 +169,12 @@ const CONFIG = (() => {
         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,
+        // 兼容：若只传了 --ai-count，则默认 groupSize=aiCount
+        groupSize: Math.max(1, Number(groupSizeRaw) || (Number(aiCountRaw) || 7)),
+        // SparkArray：每组参与汇聚的实例数量（不超过该组实际 controller 数量）
+        sparkNumAI: Math.max(1, Number(sparkNumAiRaw) || (Number(groupSizeRaw) || (Number(aiCountRaw) || 7))),
+        // SparkArray：低精度预算（可传 preset：default/low/high，或 JSON 对象）
+        sparkBudget: sparkBudgetRaw,
         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'),
@@ -77,11 +182,24 @@ const CONFIG = (() => {
         maxWorkers: Math.max(1, (os.cpus()?.length ?? 2) - 1),
         shardCache: path.join(__dirname, 'shards_cache.json'),
         lmdbRoot: path.join(args['lmdb-dir'] || process.env.LMDB_DIR || path.join(__dirname, 'lmdb')),
+        lmdbMapSizeBytes: Math.max(64, Number(lmdbMapMbRaw) || 512) * 1024 * 1024,
         searchEndpoint: args['search-endpoint'] || process.env.AI_SEARCH_ENDPOINT || '',
         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')),
+        lemmaAutoload: boolFrom(args['lemma-autoload'] ?? process.env.AI_LEMMA_AUTOLOAD, false),
+        lemmaMaxBytes: Math.max(1, Number(lemmaMaxMbRaw) || 64) * 1024 * 1024,
+        lemmaForce: boolFrom(args['lemma-force'] ?? process.env.AI_LEMMA_FORCE, false),
         robotsWarmupLimit: Math.max(0, Number(robotsLimitRaw) || 0),
         robotsAutoload: boolFrom(args['robots-autoload'] ?? process.env.AI_ROBOTS_AUTOLOAD, true),
+        robotsWarmupShuffle: boolFrom(args['robots-warmup-shuffle'] ?? process.env.AI_ROBOTS_WARMUP_SHUFFLE, false),
+        robotsChunkMinWords: Math.max(1, Number(robotsChunkMinRaw) || 2),
+        robotsChunkMaxWords: Math.max(1, Number(robotsChunkMaxRaw) || 5),
+        kvmCacheMaxEntries: Math.max(0, Number(kvmCacheMaxRaw) || 0),
+        learningWarmup: boolFrom(args['learning-warmup'] ?? process.env.AI_LEARNING_WARMUP, false),
+        // 启动时是否把 serving 的 snapshot 同步到 standby/validation（可能很慢；默认关闭以保证 fast-boot）
+        syncStandbyOnBoot: boolFrom(args['sync-standby'] ?? process.env.AI_SYNC_STANDBY_ON_BOOT, false),
+        // tests 语料预加载（可能较慢；默认开启，fast-boot 可设为 false）
+        testsAutoload: boolFrom(args['tests-autoload'] ?? process.env.AI_TESTS_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,
@@ -99,7 +217,7 @@ ensureDir(CONFIG.robotsDir);
 const LMDB = safeRequire('lmdb');
 
 class LmdbStore {
-    constructor({ name, rootDir, encodeJSON = true }) {
+    constructor({ name, rootDir, encodeJSON = true, mapSizeBytes } = {}) {
         this.name = name;
         this.rootDir = rootDir;
         this.encodeJSON = encodeJSON;
@@ -109,10 +227,13 @@ class LmdbStore {
             try {
                 const envPath = path.join(rootDir, name);
                 ensureDir(envPath);
+                const resolvedMapSize = Number.isFinite(Number(mapSizeBytes)) && Number(mapSizeBytes) > 0
+                    ? Number(mapSizeBytes)
+                    : 512 * 1024 * 1024;
                 this.env = this.backend.open({
                     path: envPath,
                     maxReaders: 64,
-                    mapSize: 1024 * 1024 * 1024,
+                    mapSize: resolvedMapSize,
                     useWritemap: true,
                     noSync: false
                 });
@@ -352,10 +473,40 @@ const compileCustomFunctionSafely = (source, argNames, fallback) => {
     }
 };
 
+/**
+ * 模型外参/超参（面向调参/评测；与 CLI/ENV 无关）
+ *
+ * 修改方式：
+ * - 运行时 patch：POST /api/model/params 传入 { key: value }
+ * - 恢复默认：POST /api/model/params/reset
+ * - 读取当前值：GET  /api/model/params
+ *
+ * 逐项说明（默认值以此处为准）：
+ * - iteration (5): 传播迭代步数；用于 RuntimeState.runPropagation()/exportGraphToFile() -> TensorEngine.iteratePropagation().
+ * - decayK (1): 传播衰减系数；传给 TensorEngine.iteratePropagation(csr, seeds, steps, actFn, decayK, damp).
+ *
+ * - memeNgramMin (2) / memeNgramMax (4): 构建“短语模因(ngram)”的长度范围；用于 mapWordsToMemes() 与 _buildMemeSequenceFromTokens().
+ * - minOverlapThreshold (2): tokenSet 与既有 meme 的最小重合词数；满足则“融合”到该 meme（link 词 -> meme）。
+ * - maxMemeWords (100): tokenSet 去重后的最大词数上限（用于限制短语模因的词集合大小）。
+ *
+ * - maliciousThreshold (0.7): MemeBarrier 判定阈值（网关侧安全屏障）；也可通过 PATCH /api/runtime/features 调整。
+ *
+ * - activationType ('relu'): 激活函数类型；用于 _activation()。
+ *   - 可用类型见 module.exports.BUILTIN_ACTIVATION_TYPES；当为 'custom' 时使用 activationCustom。
+ * - activationCustom (''): 自定义激活函数源码（function(x){...} 或表达式）；仅 activationType='custom' 时生效。
+ *
+ * - transferType ('linear') / transferCustom (''):
+ *   - 预留：目前本文件内未在主传播路径中调用（仅实现了 _transfer() 与 BuiltinTransfers）。
+ *
+ * - decayFactor (0.5), learningIterations (3), threshold (3), decay (1), maxLen (16), edgeWeight (1):
+ *   - 预留：当前版本 main.cjs 中未发现显式读取点（可能供未来/外部实验使用）。
+ */
 const modelDefaults = {
     decayFactor: 0.5,
     maxMemeWords: 100,
     minOverlapThreshold: 2,
+    memeNgramMin: 3,
+    memeNgramMax: 14,
     maliciousThreshold: 0.7,
     learningIterations: 3,
     iteration: 5,
@@ -367,7 +518,12 @@ const modelDefaults = {
     activationType: 'relu',
     transferType: 'linear',
     activationCustom: '',
-    transferCustom: ''
+    transferCustom: '',
+    // 多次映射/镜面反射层（文明演算法思想）：words -> memes -> words -> memes ...
+    mappingDepth: 1,
+    reflectionTopMemes: 18,
+    reflectionTopWords: 24,
+    reflectionMinScore: 1e-6
 };
 
 const hashString = (str) => {
@@ -389,7 +545,7 @@ const tokenize = (text) => {
         if (!part) {
             continue;
         }
-        if (/^[a-z0-9_\-]+$/.test(part) && STOP_WORDS.includes(part)) {
+        if (/^[a-z0-9_\-]+$/.test(part) && getStopWords().includes(part)) {
             continue;
         }
         tokens.push(part);
@@ -397,21 +553,388 @@ const tokenize = (text) => {
     return tokens;
 };
 
+const splitSentences = (text) => {
+    const raw = String(text || '').trim();
+    if (!raw) {
+        return [];
+    }
+
+    // 说明：此函数用于“轻量切分成可学习/可检索的文本单元”。
+    // 这里不再按标点分句作为唯一粒度，而是将文本切成“2-10 个词”的短片段。
+    // 这样 robots 语料、surface phrase 抽取等模块能获得更细粒度的共现结构。
+    const maxWords = 10;
+    const minWords = 2;
+
+    // 先粗分段（保留换行/句末标点作为天然边界），再在段内按词切块。
+    const rough = raw
+        .split(/[\r\n]+|(?<=[。！？!?])\s*/g)
+        .map((s) => String(s || '').trim())
+        .filter(Boolean);
+
+    const out = [];
+    for (const unit of rough) {
+        const tokens = tokenize(unit);
+        if (tokens.length < minWords) {
+            continue;
+        }
+
+        for (let i = 0; i < tokens.length; i += maxWords) {
+            const chunk = tokens.slice(i, i + maxWords);
+            if (chunk.length < minWords) {
+                // 末尾不足 2 词：尽量并入上一块
+                if (out.length) {
+                    out[out.length - 1] = `${out[out.length - 1]} ${chunk.join(' ')}`.trim();
+                }
+                continue;
+            }
+            out.push(chunk.join(' '));
+            if (out.length >= 12) {
+                return out;
+            }
+        }
+
+        if (out.length >= 12) {
+            break;
+        }
+    }
+
+    return out.slice(0, 12);
+};
+
+const extractSurfacePhrases = (text, { maxPhrases = 24 } = {}) => {
+    const out = [];
+    const seen = new Set();
+
+    const push = (phrase, weight = 1) => {
+        const p = String(phrase || '').trim();
+        if (!p) return;
+        if (p.length < 2) return;
+        if (p.length > 160) return;
+        if (seen.has(p)) return;
+        seen.add(p);
+        out.push({ phrase: p, weight });
+    };
+
+    // 细化：优先保留“词/短语结构”，句子仅作弱特征。
+    const sentences = splitSentences(text);
+    for (const s of sentences) {
+        push(s, 1);
+    }
+
+    const tokens = tokenize(text);
+    if (tokens.length) {
+        // unigram
+        for (const t of tokens.slice(0, maxPhrases)) {
+            push(t, 2);
+            if (out.length >= maxPhrases) {
+                return out.slice(0, maxPhrases);
+            }
+        }
+
+        // n-gram (短语)
+        const maxN = Math.min(5, tokens.length);
+        for (let n = 2; n <= maxN; n++) {
+            for (let i = 0; i + n <= tokens.length; i++) {
+                const gram = tokens.slice(i, i + n).join(' ');
+                const w = n === 2 ? 3 : (n === 3 ? 2 : 1);
+                push(gram, w);
+                if (out.length >= maxPhrases) {
+                    return out.slice(0, maxPhrases);
+                }
+            }
+        }
+    }
+
+    return out.slice(0, maxPhrases);
+};
+
+class MemeSurfaceLexicon {
+    constructor(store, {
+        maxEntriesPerMeme = 64,
+        decay = 0.985
+    } = {}) {
+        this.store = store;
+        this.maxEntriesPerMeme = Math.max(8, Number(maxEntriesPerMeme) || 64);
+        this.decay = Number.isFinite(Number(decay)) ? Number(decay) : 0.985;
+    }
+
+    _key(memeId) {
+        return `m:${String(memeId)}`;
+    }
+
+    _load(memeId) {
+        const raw = this.store.get(this._key(memeId));
+        if (!raw || typeof raw !== 'object') {
+            return { phrases: {}, updatedAt: 0 };
+        }
+        const phrases = raw.phrases && typeof raw.phrases === 'object' ? raw.phrases : {};
+        return { phrases, updatedAt: Number(raw.updatedAt || 0) || 0 };
+    }
+
+    _save(memeId, rec) {
+        this.store.put(this._key(memeId), rec);
+    }
+
+    learn(memeId, replyText, { weight = 1 } = {}) {
+        if (!memeId) return;
+        const w = Number.isFinite(Number(weight)) ? Number(weight) : 1;
+        const rec = this._load(memeId);
+        const next = { phrases: { ...rec.phrases }, updatedAt: Date.now() };
+
+        // 对旧条目做轻量衰减，防止早期噪声长期占据。
+        for (const [k, v] of Object.entries(next.phrases)) {
+            const nv = (Number(v) || 0) * this.decay;
+            if (nv <= 1e-6) {
+                delete next.phrases[k];
+            } else {
+                next.phrases[k] = nv;
+            }
+        }
+
+        const phrases = extractSurfacePhrases(replyText, { maxPhrases: 24 });
+        for (const p of phrases) {
+            next.phrases[p.phrase] = (Number(next.phrases[p.phrase]) || 0) + (p.weight * w);
+        }
+
+        // 裁剪到 topN
+        const ordered = Object.entries(next.phrases)
+            .sort((a, b) => (Number(b[1]) || 0) - (Number(a[1]) || 0))
+            .slice(0, this.maxEntriesPerMeme);
+        next.phrases = Object.fromEntries(ordered);
+        this._save(memeId, next);
+    }
+
+    getTop(memeId, { limit = 6 } = {}) {
+        const rec = this._load(memeId);
+        const ordered = Object.entries(rec.phrases || {})
+            .sort((a, b) => (Number(b[1]) || 0) - (Number(a[1]) || 0))
+            .slice(0, Math.max(1, Number(limit) || 6))
+            .map(([phrase, score]) => ({ phrase, score: Number(score) || 0 }));
+        return ordered;
+    }
+
+    exportSnapshot({ limitMemes = 512 } = {}) {
+        const out = [];
+        const items = this.store.entries('m:');
+        for (const [key, value] of items) {
+            out.push([key, value]);
+            if (out.length >= limitMemes) break;
+        }
+        return out;
+    }
+
+    importSnapshot(entries) {
+        if (!Array.isArray(entries)) return;
+        for (const item of entries) {
+            if (!Array.isArray(item) || item.length !== 2) continue;
+            const [key, value] = item;
+            if (typeof key !== 'string' || !key.startsWith('m:')) continue;
+            this.store.put(key, value);
+        }
+    }
+}
+
+const jaccard = (a, b) => {
+    const A = a instanceof Set ? a : new Set(Array.isArray(a) ? a : []);
+    const B = b instanceof Set ? b : new Set(Array.isArray(b) ? b : []);
+    if (A.size === 0 && B.size === 0) return 1;
+    if (A.size === 0 || B.size === 0) return 0;
+    let inter = 0;
+    for (const x of A) if (B.has(x)) inter++;
+    const uni = A.size + B.size - inter;
+    return uni <= 0 ? 0 : inter / uni;
+};
+
+class DialogMemory {
+    constructor(store, {
+        maxItems = 2048,
+        maxPerIndex = 64
+    } = {}) {
+        this.store = store;
+        this.maxItems = Math.max(128, Number(maxItems) || 2048);
+        this.maxPerIndex = Math.max(8, Number(maxPerIndex) || 64);
+    }
+
+    _kDialog(id) {
+        return `d:${String(id)}`;
+    }
+
+    _kIndex(memeId) {
+        return `i:${String(memeId)}`;
+    }
+
+    _makeId(signature) {
+        return hashString(String(signature || ''));
+    }
+
+    remember({ signature, memes = [], question = '', reply = '', scoreHint = 0 } = {}) {
+        const sig = String(signature || '').trim();
+        const rep = String(reply || '').trim();
+        if (!sig || !rep) return null;
+        const id = this._makeId(sig);
+        const key = this._kDialog(id);
+        const prev = this.store.get(key);
+        const next = {
+            id,
+            signature: sig,
+            memes: Array.isArray(memes) ? memes.slice(0, 32) : [],
+            question: String(question || '').slice(0, 800),
+            reply: rep.slice(0, 1200),
+            updatedAt: Date.now(),
+            count: (prev && Number(prev.count)) ? (Number(prev.count) + 1) : 1,
+            scoreHint: Number.isFinite(Number(scoreHint)) ? Number(scoreHint) : (prev?.scoreHint ?? 0)
+        };
+        this.store.put(key, next);
+
+        // 建索引：memeId -> dialogIds[]
+        const uniq = Array.from(new Set(next.memes));
+        for (const memeId of uniq) {
+            const ik = this._kIndex(memeId);
+            const list = Array.isArray(this.store.get(ik)) ? this.store.get(ik) : [];
+            const filtered = list.filter((x) => x && x !== id);
+            filtered.unshift(id);
+            this.store.put(ik, filtered.slice(0, this.maxPerIndex));
+        }
+
+        return next;
+    }
+
+    retrieve({ memes = [], signature = '', minSim = 0.45 } = {}) {
+        const memeList = Array.isArray(memes) ? memes.slice(0, 24) : [];
+        const sigSet = new Set(String(signature || '').split('|').filter(Boolean));
+        const candidateIds = new Set();
+        for (const memeId of memeList.slice(0, 8)) {
+            const ik = this._kIndex(memeId);
+            const ids = Array.isArray(this.store.get(ik)) ? this.store.get(ik) : [];
+            for (const id of ids) {
+                if (id) candidateIds.add(id);
+            }
+        }
+
+        // 如果没有索引命中，尝试精确 signature 命中
+        if (candidateIds.size === 0 && signature) {
+            candidateIds.add(this._makeId(signature));
+        }
+
+        let best = null;
+        let bestScore = 0;
+        for (const id of candidateIds) {
+            const rec = this.store.get(this._kDialog(id));
+            if (!rec || !rec.reply) continue;
+            const recSet = new Set(String(rec.signature || '').split('|').filter(Boolean));
+            const sim = jaccard(sigSet, recSet);
+            if (sim < minSim) continue;
+            const freq = Math.log(1 + (Number(rec.count) || 0));
+            const score = sim * (1 + 0.15 * freq);
+            if (score > bestScore) {
+                bestScore = score;
+                best = { ...rec, similarity: sim, score };
+            }
+        }
+        return best;
+    }
+
+    exportSnapshot({ limit = 512 } = {}) {
+        const out = { dialogs: [], indexes: [] };
+        const dialogs = this.store.entries('d:');
+        for (const [key, value] of dialogs) {
+            out.dialogs.push([key, value]);
+            if (out.dialogs.length >= limit) break;
+        }
+        const indexes = this.store.entries('i:');
+        for (const [key, value] of indexes) {
+            out.indexes.push([key, value]);
+            if (out.indexes.length >= limit) break;
+        }
+        return out;
+    }
+
+    importSnapshot(snapshot) {
+        if (!snapshot || typeof snapshot !== 'object') return;
+        for (const item of Array.isArray(snapshot.dialogs) ? snapshot.dialogs : []) {
+            if (!Array.isArray(item) || item.length !== 2) continue;
+            const [key, value] = item;
+            if (typeof key === 'string' && key.startsWith('d:')) this.store.put(key, value);
+        }
+        for (const item of Array.isArray(snapshot.indexes) ? snapshot.indexes : []) {
+            if (!Array.isArray(item) || item.length !== 2) continue;
+            const [key, value] = item;
+            if (typeof key === 'string' && key.startsWith('i:')) this.store.put(key, value);
+        }
+    }
+}
+
 class RobotsCorpus {
-    constructor({ dir, lemmaCsv }) {
+    constructor({
+        dir,
+        lemmaCsv,
+        lemmaAutoload = false,
+        lemmaMaxBytes,
+        lemmaForce = false,
+        chunkMinWords = 2,
+        chunkMaxWords = 5
+    } = {}) {
         this.dir = dir;
         this.lemmaCsv = lemmaCsv;
-        this.lemmaMap = this._loadLemmaMap();
+        this.lemmaAutoload = Boolean(lemmaAutoload);
+        this.lemmaForce = Boolean(lemmaForce);
+        this.lemmaMaxBytes = Number.isFinite(Number(lemmaMaxBytes)) && Number(lemmaMaxBytes) > 0
+            ? Number(lemmaMaxBytes)
+            : 64 * 1024 * 1024;
+        this.chunkMinWords = Math.max(1, Number(chunkMinWords) || 2);
+        this.chunkMaxWords = Math.max(this.chunkMinWords, Number(chunkMaxWords) || 5);
+        this._lemmaLoaded = false;
+        this.lemmaMap = new Map();
         this.maxArticleSize = 5_000_000;
         this.minParagraphLength = 12;
     }
 
+    _chunkTokens(tokens) {
+        const out = [];
+        if (!Array.isArray(tokens) || tokens.length === 0) {
+            return out;
+        }
+        const maxN = Math.max(1, this.chunkMaxWords);
+        const minN = Math.max(1, this.chunkMinWords);
+        for (let i = 0; i < tokens.length; i += maxN) {
+            const chunk = tokens.slice(i, i + maxN);
+            if (chunk.length >= minN) {
+                out.push(chunk);
+            }
+        }
+        return out;
+    }
+
+    _ensureLemmaMapLoaded() {
+        if (this._lemmaLoaded) {
+            return;
+        }
+        this._lemmaLoaded = true;
+        if (!this.lemmaAutoload && !this.lemmaForce) {
+            return;
+        }
+        this.lemmaMap = this._loadLemmaMap();
+    }
+
     _loadLemmaMap() {
         const map = new Map();
+        const csvParse = getCsvParse();
         if (!csvParse || !this.lemmaCsv || !fs.existsSync(this.lemmaCsv)) {
             return map;
         }
         try {
+            try {
+                const st = fs.statSync(this.lemmaCsv);
+                if (!this.lemmaForce && st && Number.isFinite(st.size) && st.size > this.lemmaMaxBytes) {
+                    console.warn(
+                        `[RobotsCorpus] lemma.csv too large (${Math.round(st.size / 1024 / 1024)}MB), skip autoload. ` +
+                        `Set AI_LEMMA_FORCE=true or increase AI_LEMMA_MAX_MB to load.`
+                    );
+                    return map;
+                }
+            } catch (_e) {
+                // ignore stat failure
+            }
             const csvContent = fs.readFileSync(this.lemmaCsv, 'utf8');
             const rows = csvParse.parse(csvContent, { skip_empty_lines: true, relax_column_count: true });
             for (const row of rows) {
@@ -437,6 +960,7 @@ class RobotsCorpus {
     }
 
     lemmatize(word) {
+        this._ensureLemmaMapLoaded();
         const lower = String(word || '').toLowerCase();
         return this.lemmaMap.get(lower) || lower;
     }
@@ -466,11 +990,21 @@ class RobotsCorpus {
     _readFile(file) {
         const full = path.join(this.dir, file);
         try {
-            let content = fs.readFileSync(full, 'utf8');
-            if (content.length > this.maxArticleSize) {
-                content = content.slice(0, this.maxArticleSize);
+            // 关键优化：避免对超大语料文件做一次性 readFileSync（会把整个文件读进内存）
+            // 这里仅读取前 maxArticleSize 字节（近似等价于之前的 slice 行为）。
+            const fd = fs.openSync(full, 'r');
+            try {
+                const maxBytes = Math.max(1, Number(this.maxArticleSize) || 1);
+                const buf = Buffer.allocUnsafe(maxBytes);
+                const bytesRead = fs.readSync(fd, buf, 0, maxBytes, 0);
+                return buf.toString('utf8', 0, Math.max(0, bytesRead || 0));
+            } finally {
+                try {
+                    fs.closeSync(fd);
+                } catch (_e) {
+                    // ignore close failure
+                }
             }
-            return content;
         } catch (err) {
             console.warn(`[RobotsCorpus] Failed to read ${full}:`, err.message);
             return '';
@@ -510,30 +1044,38 @@ class RobotsCorpus {
             for (const paragraph of paragraphs) {
                 const trimmed = paragraph.trim();
                 if (trimmed.length < this.minParagraphLength) {
-                    localIndex += 1;
-                    continue;
-                }
-                if (skip > 0) {
-                    skip -= 1;
-                    localIndex += 1;
                     continue;
                 }
-                const tokens = this.normalizeWords(tokenize(trimmed));
-                if (!tokens.length) {
+
+                // 新逻辑：按句子切分，再按 2-5 词（可配置）切块生成 doc
+                // 这样每条 doc 更接近“短语/局部词共现”，利于词表/模因边的细粒度学习。
+                // 注意：splitSentences() 已改为输出“2-10 词”的短片段；这里不再做二次切块。
+                const units = splitSentences(trimmed);
+                for (const unit of units) {
+                    const unitText = String(unit || '').trim();
+                    if (unitText.length < this.minParagraphLength) {
+                        continue;
+                    }
+                    const normalizedTokens = this.normalizeWords(tokenize(unitText));
+                    if (!normalizedTokens.length) {
+                        continue;
+                    }
+                    if (skip > 0) {
+                        skip -= 1;
+                        continue;
+                    }
+                    docs.push({
+                        id: `robots:${file}#${localIndex}`,
+                        file,
+                        source: `robots:${file}`,
+                        index: localIndex,
+                        text: unitText,
+                        tokens: normalizedTokens
+                    });
                     localIndex += 1;
-                    continue;
-                }
-                docs.push({
-                    id: `robots:${file}#${localIndex}`,
-                    file,
-                    source: `robots:${file}`,
-                    index: localIndex,
-                    text: trimmed,
-                    tokens
-                });
-                localIndex += 1;
-                if (maxDocs !== null && docs.length >= maxDocs) {
-                    return shuffle && docs.length > 1 ? this._shuffle(docs) : docs;
+                    if (maxDocs !== null && docs.length >= maxDocs) {
+                        return shuffle && docs.length > 1 ? this._shuffle(docs) : docs;
+                    }
                 }
             }
         }
@@ -546,9 +1088,41 @@ class RobotsCorpus {
 }
 
 class KVMStore {
-    constructor(store) {
+    constructor(store, { maxCacheEntries } = {}) {
         this.store = store;
         this.cache = new Map();
+        this.maxCacheEntries = Number.isFinite(Number(maxCacheEntries)) && Number(maxCacheEntries) >= 0
+            ? Number(maxCacheEntries)
+            : 50_000;
+    }
+
+    _cacheGet(key) {
+        if (!this.maxCacheEntries) {
+            return null;
+        }
+        if (!this.cache.has(key)) {
+            return null;
+        }
+        const value = this.cache.get(key);
+        // LRU: bump to most-recent
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+    }
+
+    _cacheSet(key, value) {
+        if (!this.maxCacheEntries) {
+            return;
+        }
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        this.cache.set(key, value);
+        while (this.cache.size > this.maxCacheEntries) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest === undefined) break;
+            this.cache.delete(oldest);
+        }
     }
 
     _key(type, value) {
@@ -557,23 +1131,21 @@ class KVMStore {
 
     getWordMemeSet(word) {
         const key = this._key('word', word);
-        if (this.cache.has(key)) {
-            return this.cache.get(key);
-        }
+        const cached = this._cacheGet(key);
+        if (cached) return cached;
         const value = this.store.get(key) || [];
         const set = new Set(value);
-        this.cache.set(key, set);
+        this._cacheSet(key, set);
         return set;
     }
 
     getMemeWords(memeId) {
         const key = this._key('meme', memeId);
-        if (this.cache.has(key)) {
-            return this.cache.get(key);
-        }
+        const cached = this._cacheGet(key);
+        if (cached) return cached;
         const value = this.store.get(key) || [];
         const set = new Set(value);
-        this.cache.set(key, set);
+        this._cacheSet(key, set);
         return set;
     }
 
@@ -585,12 +1157,12 @@ class KVMStore {
         if (!wordSet.has(memeId)) {
             wordSet.add(memeId);
             this.store.put(wordKey, Array.from(wordSet));
-            this.cache.set(wordKey, wordSet);
+            this._cacheSet(wordKey, wordSet);
         }
         if (!memeSet.has(word)) {
             memeSet.add(word);
             this.store.put(memeKey, Array.from(memeSet));
-            this.cache.set(memeKey, memeSet);
+            this._cacheSet(memeKey, memeSet);
         }
     }
 
@@ -626,36 +1198,80 @@ class CSRMatrix {
 }
 
 class MemeGraph {
-    constructor(store) {
+    constructor(store, { eagerLoad = false } = {}) {
         this.store = store;
         this.nodes = new Map();
         this.meta = new Map();
         this.windowSize = 4096;
-        this._load();
+        this._fullyLoaded = false;
+        if (eagerLoad) {
+            this._loadAllFromStore();
+        }
     }
 
-    _load() {
+    _loadAllFromStore() {
+        if (this._fullyLoaded) {
+            return;
+        }
         const entries = this.store.entries('node:');
         for (const [key, value] of entries) {
             const memeId = key.slice(5);
-            this.meta.set(memeId, value || {});
+            if (!this.meta.has(memeId)) {
+                this.meta.set(memeId, value || {});
+            }
         }
         const rowEntries = this.store.entries('row:');
         for (const [key, row] of rowEntries) {
             const memeId = key.slice(4);
+            if (this.nodes.has(memeId)) {
+                continue;
+            }
             if (!row || !Array.isArray(row.neighbors)) {
                 continue;
             }
             const map = new Map();
             for (const { to, weight, direction } of row.neighbors) {
-                map.set(to, { weight, direction });
+                map.set(String(to), { weight, direction });
             }
             this.nodes.set(memeId, map);
         }
+        this._fullyLoaded = true;
+    }
+
+    _ensureRowLoaded(memeId) {
+        const id = String(memeId);
+        if (this.nodes.has(id)) {
+            return this.nodes.get(id);
+        }
+        const row = this.store.get(`row:${id}`);
+        if (row && Array.isArray(row.neighbors)) {
+            const map = new Map();
+            for (const { to, weight, direction } of row.neighbors) {
+                map.set(String(to), { weight, direction });
+            }
+            this.nodes.set(id, map);
+            return map;
+        }
+        return null;
+    }
+
+    _ensureMetaLoaded(memeId) {
+        const id = String(memeId);
+        if (this.meta.has(id)) {
+            return this.meta.get(id);
+        }
+        const meta = this.store.get(`node:${id}`);
+        if (meta && typeof meta === 'object') {
+            this.meta.set(id, meta);
+            return meta;
+        }
+        return null;
     }
 
     // 返回当前图中所有模因节点的ID列表，供扫描器等模块使用
     getAllPoints() {
+        // 需要全量枚举时才进行全量加载，避免启动时扫描整个 store。
+        this._loadAllFromStore();
         return Array.from(this.meta.keys());
     }
 
@@ -668,11 +1284,26 @@ class MemeGraph {
     }
 
     ensureNode(memeId) {
-        if (!this.nodes.has(memeId)) {
-            this.nodes.set(memeId, new Map());
-            this.meta.set(memeId, { degree: 0, lastTouched: Date.now() });
-            this.store.put(`node:${memeId}`, this.meta.get(memeId));
-            this._persistNode(memeId);
+        const id = String(memeId);
+        if (!this.nodes.has(id)) {
+            const loaded = this._ensureRowLoaded(id);
+            if (!loaded) {
+                this.nodes.set(id, new Map());
+            }
+        }
+        if (!this.meta.has(id)) {
+            const loadedMeta = this._ensureMetaLoaded(id);
+            if (!loadedMeta) {
+                this.meta.set(id, { degree: 0, lastTouched: Date.now() });
+                this.store.put(`node:${id}`, this.meta.get(id));
+            }
+        }
+        if (!this.nodes.get(id)) {
+            this.nodes.set(id, new Map());
+        }
+        // 若节点此前不存在于 store，确保 row 持久化
+        if (!this.store.get(`row:${id}`)) {
+            this._persistNode(id);
         }
     }
 
@@ -725,7 +1356,7 @@ class MemeGraph {
         while (border.length && visited.size < this.windowSize && depth < radius) {
             const next = [];
             for (const id of border) {
-                const table = this.nodes.get(id);
+                const table = this.nodes.get(id) || this._ensureRowLoaded(id);
                 if (!table) {
                     continue;
                 }
@@ -746,7 +1377,7 @@ class MemeGraph {
         const weights = [];
         for (let i = 0; i < ids.length; i++) {
             const id = ids[i];
-            const table = this.nodes.get(id) || new Map();
+            const table = this.nodes.get(id) || this._ensureRowLoaded(id) || new Map();
             rowPtr[i] = edges.length;
             for (const [toId, { weight }] of table.entries()) {
                 if (!index.has(toId)) {
@@ -768,6 +1399,8 @@ class MemeGraph {
     }
 
     exportSnapshot() {
+        // 导出需要全量内容；若尚未加载则在此时执行全量加载。
+        this._loadAllFromStore();
         const nodes = [];
         for (const [id, table] of this.nodes.entries()) {
             nodes.push({
@@ -796,6 +1429,8 @@ class MemeGraph {
     }
 
     removeNode(memeId) {
+        // 删除需要一致性：先全量加载再删，避免遗漏未加载节点中的反向边。
+        this._loadAllFromStore();
         if (!this.nodes.has(memeId)) {
             return false;
         }
@@ -1071,6 +1706,7 @@ class DimReducer {
     }
 
     project2D(emb, method = 'auto') {
+        const umap = getUmap();
         if (method === 'umap' && umap) {
             const dataset = [];
             for (let row = 0; row < emb.nRows; row++) {
@@ -1182,7 +1818,7 @@ class OnlineResearcher {
                 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 crawler = new SiteCrawler({ axios: getAxios(), cheerio: getCheerio(), pdfParse: getPdfParse() });
             const result = await crawler.crawl(startUrl, crawlOptions);
             if (!options?.forceRemote) {
                 const key = this._normalize(tokenize(`crawl ${startUrl}`));
@@ -1204,6 +1840,7 @@ class OnlineResearcher {
         }
 
         let payload = null;
+        const axios = getAxios();
         if (axios && this.endpoint && !options.skipRemote) {
             try {
                 const resp = await axios.get(this.endpoint, {
@@ -1502,14 +2139,6 @@ class SessionManager {
         this.idleMs = idleMs;
         this.maxSessions = maxSessions;
         this.active = new Map();
-        this._load();
-    }
-
-    _load() {
-        const entries = this.store.entries('session:');
-        for (const [key, value] of entries) {
-            this.active.set(key.slice(8), value);
-        }
     }
 
     _save(sessionId) {
@@ -1524,12 +2153,28 @@ class SessionManager {
     }
 
     ensure(sessionId) {
-        if (sessionId && this.active.has(sessionId)) {
-            const data = this.active.get(sessionId);
-            data.lastActivity = Date.now();
-            data.count = (data.count || 0) + 1;
-            this._save(sessionId);
-            return sessionId;
+        if (sessionId) {
+            const sid = String(sessionId);
+            if (this.active.has(sid)) {
+                const data = this.active.get(sid);
+                data.lastActivity = Date.now();
+                data.count = (data.count || 0) + 1;
+                this._save(sid);
+                return sid;
+            }
+            // 懒加载：仅在客户端携带 sessionId 时才从 store 读取
+            const stored = this.store.get(`session:${sid}`);
+            if (stored && typeof stored === 'object') {
+                const data = { ...stored, id: stored.id || sid };
+                data.lastActivity = Date.now();
+                data.count = (data.count || 0) + 1;
+                this.active.set(sid, data);
+                this._save(sid);
+                if (this.active.size > this.maxSessions) {
+                    this._truncate();
+                }
+                return sid;
+            }
         }
         const id = this._newId();
         this.active.set(id, { id, createdAt: Date.now(), lastActivity: Date.now(), count: 1, meta: {} });
@@ -1591,7 +2236,7 @@ class SnapshotManager {
         }
         const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
         await this.runtime.fromSnapshot(raw);
-        return true;
+        return raw;
     }
 
     delete(id) {
@@ -1647,16 +2292,28 @@ class GraphExportBuilder {
 
 class RuntimeState {
     constructor({ kvmStore, memeStore, sessionStore, params, config }) {
-        this.kvm = new KVMStore(kvmStore);
+        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.config.lemmaAutoload = this.config.lemmaAutoload ?? false;
+        this.config.lemmaMaxBytes = this.config.lemmaMaxBytes ?? (64 * 1024 * 1024);
+        this.config.lemmaForce = this.config.lemmaForce ?? false;
+        this.config.kvmCacheMaxEntries = this.config.kvmCacheMaxEntries ?? 50_000;
+        this.config.robotsChunkMinWords = this.config.robotsChunkMinWords ?? 2;
+        this.config.robotsChunkMaxWords = this.config.robotsChunkMaxWords ?? 5;
+
+        this.kvm = new KVMStore(kvmStore, { maxCacheEntries: this.config.kvmCacheMaxEntries });
         this.graph = new MemeGraph(memeStore);
         this.sessions = new SessionManager(sessionStore);
+        // “反接”层：从模因层回到用户可读表达（短语/句子）
+        this.surfaceStore = new NamespacedStore(sessionStore, 'surface');
+        this.dialogStore = new NamespacedStore(sessionStore, 'dialog');
+        this.surfaceLexicon = new MemeSurfaceLexicon(this.surfaceStore);
+        this.dialogMemory = new DialogMemory(this.dialogStore);
         this.tensor = new TensorEngine();
         this.pattern = new PatternMatrix(this);
         this.params = { ...modelDefaults, ...(params || {}) };
         this.metrics = { requests: 0, lastLatency: 0, updatedAt: Date.now() };
-        this.config = { ...(config || {}) };
-        this.config.robotsDir = this.config.robotsDir || path.join(__dirname, 'robots');
-        this.config.lemmaCsv = this.config.lemmaCsv || path.join(__dirname, 'lemma.csv');
         // 在线搜索配置：支持运行时开关与 endpoint 库
         this.config.search = {
             enabled: this.config.search?.enabled ?? true,
@@ -1740,8 +2397,14 @@ class RuntimeState {
     }
 
     mapWordsToMemes(words) {
+        // 细化：输入不仅映射到“单词模因”，还会生成/融合“多词模因(短语模因)”。
+        const tokens = Array.isArray(words) ? words.map((w) => String(w || '').trim()).filter(Boolean) : [];
         const memeStrength = new Map();
-        for (const word of words) {
+        const maxUnits = 128;
+        let units = 0;
+
+        // 1) unigram：保持兼容
+        for (const word of tokens) {
             const memes = this.kvm.getWordMemeSet(word);
             if (!memes || memes.size === 0) {
                 const memeId = `meme_${hashString(word)}`;
@@ -1754,9 +2417,143 @@ class RuntimeState {
                 memeStrength.set(memeId, (memeStrength.get(memeId) ?? 0) + 1);
             }
         }
+
+        // 2) phrase/word-structure meme：以 ngram 作为概念单元，模因仍为“多个词的集合”
+        const nMin = Math.max(2, Number(this.params.memeNgramMin ?? 2) || 2);
+        const nMax = Math.max(nMin, Number(this.params.memeNgramMax ?? 4) || 4);
+        const minOverlap = Math.max(1, Number(this.params.minOverlapThreshold ?? 2) || 2);
+        const maxWordSet = Math.max(4, Number(this.params.maxMemeWords ?? 100) || 100);
+
+        const resolveOrCreateMemeForTokenSet = (tokenSet) => {
+            const uniq = Array.from(new Set(tokenSet.map((x) => String(x || '').trim()).filter(Boolean))).slice(0, maxWordSet);
+            if (uniq.length <= 1) {
+                const w = uniq[0];
+                return w ? `meme_${hashString(w)}` : null;
+            }
+            // 统计每个候选 meme 与 tokenSet 的重合词数
+            const counts = new Map();
+            for (const w of uniq) {
+                const memes = this.kvm.getWordMemeSet(w);
+                if (!memes || memes.size === 0) {
+                    continue;
+                }
+                for (const mid of memes) {
+                    counts.set(mid, (counts.get(mid) ?? 0) + 1);
+                }
+            }
+            let best = null;
+            let bestOverlap = 0;
+            for (const [mid, c] of counts.entries()) {
+                if (c > bestOverlap) {
+                    bestOverlap = c;
+                    best = mid;
+                }
+            }
+            if (best && bestOverlap >= minOverlap) {
+                // “融合”：把当前 tokenSet 的词也挂到 best meme 上
+                for (const w of uniq) {
+                    this.kvm.link(w, best);
+                }
+                this.graph.ensureNode(best);
+                return best;
+            }
+            // 新建短语模因：ID 由“词集合”决定，保证稳定
+            const sorted = uniq.slice().sort();
+            const memeId = `meme_p_${hashString(sorted.join('|'))}`;
+            this.graph.ensureNode(memeId);
+            for (const w of sorted) {
+                this.kvm.link(w, memeId);
+            }
+            return memeId;
+        };
+
+        // 生成 ngram 单元并映射到 meme，权重按长度提升
+        for (let i = 0; i < tokens.length && units < maxUnits; i++) {
+            for (let n = nMin; n <= nMax && units < maxUnits; n++) {
+                if (i + n > tokens.length) {
+                    break;
+                }
+                const gram = tokens.slice(i, i + n);
+                const memeId = resolveOrCreateMemeForTokenSet(gram);
+                if (!memeId) {
+                    continue;
+                }
+                const w = 1 + 0.5 * (n - 1);
+                memeStrength.set(memeId, (memeStrength.get(memeId) ?? 0) + w);
+                units += 1;
+            }
+        }
+
         return memeStrength;
     }
 
+    _buildMemeSequenceFromTokens(tokens) {
+        const list = Array.isArray(tokens) ? tokens.map((t) => String(t || '').trim()).filter(Boolean) : [];
+        const nMin = Math.max(2, Number(this.params.memeNgramMin ?? 2) || 2);
+        const nMax = Math.max(nMin, Number(this.params.memeNgramMax ?? 4) || 4);
+        const minOverlap = Math.max(1, Number(this.params.minOverlapThreshold ?? 2) || 2);
+        const maxWordSet = Math.max(4, Number(this.params.maxMemeWords ?? 100) || 100);
+
+        const resolveOrCreate = (tokenSet) => {
+            const uniq = Array.from(new Set(tokenSet.map((x) => String(x || '').trim()).filter(Boolean))).slice(0, maxWordSet);
+            if (uniq.length <= 1) {
+                const w = uniq[0];
+                return w ? `meme_${hashString(w)}` : null;
+            }
+            const counts = new Map();
+            for (const w of uniq) {
+                const memes = this.kvm.getWordMemeSet(w);
+                if (!memes || memes.size === 0) continue;
+                for (const mid of memes) counts.set(mid, (counts.get(mid) ?? 0) + 1);
+            }
+            let best = null;
+            let bestOverlap = 0;
+            for (const [mid, c] of counts.entries()) {
+                if (c > bestOverlap) {
+                    bestOverlap = c;
+                    best = mid;
+                }
+            }
+            if (best && bestOverlap >= minOverlap) {
+                for (const w of uniq) this.kvm.link(w, best);
+                this.graph.ensureNode(best);
+                return best;
+            }
+            const sorted = uniq.slice().sort();
+            const memeId = `meme_p_${hashString(sorted.join('|'))}`;
+            this.graph.ensureNode(memeId);
+            for (const w of sorted) this.kvm.link(w, memeId);
+            return memeId;
+        };
+
+        const seq = [];
+        for (let i = 0; i < list.length; i++) {
+            // 用更长的 ngram 优先，减少“句子级”颗粒
+            let picked = null;
+            for (let n = nMax; n >= nMin; n--) {
+                if (i + n > list.length) continue;
+                picked = resolveOrCreate(list.slice(i, i + n));
+                if (picked) {
+                    break;
+                }
+            }
+            if (!picked) {
+                const w = list[i];
+                picked = w ? `meme_${hashString(w)}` : null;
+                if (picked) {
+                    this.graph.ensureNode(picked);
+                    this.kvm.link(w, picked);
+                }
+            }
+            if (picked) {
+                if (seq.length === 0 || seq[seq.length - 1] !== picked) {
+                    seq.push(picked);
+                }
+            }
+        }
+        return seq;
+    }
+
     _buildSeedVector(windowInfo, seeds) {
         const vec = new Float32Array(windowInfo.ids.length);
         for (const [memeId, strength] of seeds.entries()) {
@@ -1768,16 +2565,101 @@ class RuntimeState {
         return vec;
     }
 
-    runPropagation(seeds) {
-        const windowInfo = this.graph.buildWindow(Array.from(seeds.keys()), 2);
+    runPropagation(seeds, options = {}) {
+        const radiusRaw = options.radius ?? options.windowRadius;
+        const radius = Math.max(1, Math.min(6, Number(radiusRaw ?? 2) || 2));
+        const windowInfo = this.graph.buildWindow(Array.from(seeds.keys()), radius);
         const seedVector = this._buildSeedVector(windowInfo, seeds);
         const act = this._activation();
-        const output = this.tensor.iteratePropagation(windowInfo.csr, seedVector, this.params.iteration || 5, act, this.params.decayK, 0.02);
+        const iteration = Math.max(1, Number(options.iteration ?? this.params.iteration ?? 5) || 5);
+        const output = this.tensor.iteratePropagation(windowInfo.csr, seedVector, iteration, act, this.params.decayK, 0.02);
         this.pattern.rebuild(windowInfo);
         return { windowInfo, seedVector, activation: output };
     }
 
+    _pickTopActivatedMemes(result, seeds, { limit = 18, minScore = 1e-6 } = {}) {
+        const { windowInfo, activation } = result || {};
+        if (!windowInfo || !Array.isArray(windowInfo.ids) || !activation) return [];
+        const seedIds = new Set(seeds ? Array.from(seeds.keys()) : []);
+
+        const isConnectedToSeeds = (memeId) => {
+            if (seedIds.size === 0 || seedIds.has(memeId)) {
+                return true;
+            }
+            const table = this.graph.nodes.get(memeId);
+            if (table) {
+                for (const neighborId of table.keys()) {
+                    if (seedIds.has(neighborId)) {
+                        return true;
+                    }
+                }
+            }
+            for (const seedId of seedIds) {
+                const seedTable = this.graph.nodes.get(seedId);
+                if (seedTable && seedTable.has(memeId)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        const scored = [];
+        for (let i = 0; i < windowInfo.ids.length; i++) {
+            const memeId = windowInfo.ids[i];
+            const score = activation[i];
+            if (!Number.isFinite(score) || score <= minScore) continue;
+            if (!isConnectedToSeeds(memeId)) continue;
+            scored.push({ memeId, score });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, Math.max(1, Number(limit) || 18));
+    }
+
+    _makeSignatureFromTopMemes(topMemes, { limit = 12 } = {}) {
+        const ids = (Array.isArray(topMemes) ? topMemes : [])
+            .map((x) => (typeof x === 'string' ? x : x?.memeId))
+            .filter(Boolean)
+            .slice(0, Math.max(3, Number(limit) || 12));
+        // signature 用 memeId 列表，排序保证稳定
+        const uniq = Array.from(new Set(ids));
+        uniq.sort();
+        return uniq.join('|');
+    }
+
     composeReply(result, words, seeds) {
+        const topMemes = this._pickTopActivatedMemes(result, seeds, { limit: 18 });
+        const signature = this._makeSignatureFromTopMemes(topMemes, { limit: 12 });
+
+        // 1) 优先：对话记忆检索（更像“在训练集中找答案”）
+        const memoryHit = this.dialogMemory.retrieve({
+            memes: topMemes.map((x) => x.memeId),
+            signature,
+            minSim: 0.45
+        });
+        if (memoryHit && typeof memoryHit.reply === 'string' && memoryHit.reply.trim()) {
+            return memoryHit.reply.trim();
+        }
+
+        // 2) 其次：模因 -> 表层表达（短语/句子）反接
+        const phraseScores = new Map();
+        for (const item of topMemes) {
+            const list = this.surfaceLexicon.getTop(item.memeId, { limit: 4 });
+            for (const c of list) {
+                const p = String(c.phrase || '').trim();
+                if (!p) continue;
+                const prev = phraseScores.get(p) ?? 0;
+                // meme 激活分数做门控，词典分数做权重
+                phraseScores.set(p, prev + (Math.max(0, item.score) * (0.5 + Math.max(0, c.score))));
+            }
+        }
+        const phraseOrdered = Array.from(phraseScores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .map(([p]) => p);
+        if (phraseOrdered.length) {
+            return phraseOrdered.slice(0, 2).join('。');
+        }
+
+        // 3) 回退：旧逻辑（meme -> words）
         const { windowInfo, activation } = result;
         const seedIds = new Set(seeds ? Array.from(seeds.keys()) : []);
         const baseWords = Array.from(new Set((words || []).map((w) => String(w).trim()).filter(Boolean)));
@@ -1857,6 +2739,48 @@ class RuntimeState {
         return finalWords.slice(0, 30).join(' ');
     }
 
+    learnFromDialog({ payload, result } = {}) {
+        try {
+            const question = typeof payload?.text === 'string'
+                ? payload.text
+                : (Array.isArray(payload?.tokens) ? payload.tokens.join(' ') : '');
+            const reply = typeof result?.reply === 'string' ? result.reply : '';
+            if (!question.trim() || !reply.trim()) {
+                return { ok: false, reason: 'missing-text' };
+            }
+
+            // 以当前推理结果为主：topMemes -> signature
+            const seeds = Array.isArray(result?.seeds)
+                ? new Map(result.seeds.map((pair) => [pair[0], pair[1]]))
+                : this.mapWordsToMemes(tokenize(question));
+            const windowInfo = Array.isArray(result?.memes) ? { ids: result.memes } : null;
+            const activation = Array.isArray(result?.activation) ? Float32Array.from(result.activation) : null;
+            const resObj = (windowInfo && activation) ? { windowInfo, activation } : this.runPropagation(seeds);
+
+            const topMemes = this._pickTopActivatedMemes(resObj, seeds, { limit: 18 });
+            const signature = this._makeSignatureFromTopMemes(topMemes, { limit: 12 });
+            const memeIds = topMemes.map((x) => x.memeId);
+
+            // 学习：每个高激活 meme 绑定 reply 的表层表达
+            for (const item of topMemes.slice(0, 10)) {
+                const w = Math.max(0.5, Math.min(3, item.score));
+                this.surfaceLexicon.learn(item.memeId, reply, { weight: w });
+            }
+
+            // 学习：签名级别的“对话记忆”（检索更直接）
+            this.dialogMemory.remember({
+                signature,
+                memes: memeIds,
+                question,
+                reply,
+                scoreHint: topMemes[0]?.score ?? 0
+            });
+            return { ok: true, memes: memeIds.length, signatureLen: signature ? signature.split('|').length : 0 };
+        } catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+
     processInput(payload) {
         const started = Date.now();
         const text = payload.text != null ? payload.text : (payload.message != null ? String(payload.message) : '');
@@ -1866,8 +2790,44 @@ class RuntimeState {
             : Array.isArray(payload.vocab) && payload.vocab.length ? payload.vocab
             : null;
         const words = tokensFromPayload ? tokensFromPayload.map((w) => String(w)) : tokenize(text);
-        const seeds = this.mapWordsToMemes(words);
-        const result = this.runPropagation(seeds);
+
+        const budget = payload && typeof payload === 'object' ? payload.budget : null;
+        const depth = Math.max(1, Number(budget?.mappingDepth ?? budget?.depth ?? this.params.mappingDepth ?? 1) || 1);
+        const topMemesK = Math.max(3, Number(budget?.reflectionTopMemes ?? budget?.topMemes ?? this.params.reflectionTopMemes ?? 18) || 18);
+        const topWordsK = Math.max(3, Number(budget?.reflectionTopWords ?? budget?.topWords ?? this.params.reflectionTopWords ?? 24) || 24);
+        const minScoreRaw = budget?.reflectionMinScore ?? budget?.minScore ?? this.params.reflectionMinScore;
+        const minScore = Number.isFinite(Number(minScoreRaw)) ? Number(minScoreRaw) : 1e-6;
+        const iterRaw = budget?.iteration;
+        const iteration = Math.max(1, Number(iterRaw ?? this.params.iteration ?? 5) || 5);
+        const radiusRaw = budget?.radius ?? budget?.windowRadius;
+        const radius = Math.max(1, Math.min(6, Number(radiusRaw ?? 2) || 2));
+
+        let seeds = this.mapWordsToMemes(words);
+        let result = null;
+        if (depth > 1) {
+            for (let hop = 1; hop < depth; hop++) {
+                result = this.runPropagation(seeds, { iteration, radius });
+                const topMemes = this._pickTopActivatedMemes(result, seeds, { limit: topMemesK, minScore });
+                const wordScore = new Map();
+                for (const m of topMemes) {
+                    const linked = this.kvm.getMemeWords(m.memeId);
+                    if (!linked) continue;
+                    for (const w of linked) {
+                        const ww = String(w || '').trim();
+                        if (!ww) continue;
+                        const prev = wordScore.get(ww) ?? 0;
+                        wordScore.set(ww, Math.max(prev, Number(m.score) || 0));
+                    }
+                }
+                const expanded = Array.from(wordScore.entries())
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, topWordsK)
+                    .map(([w]) => w);
+                const merged = Array.from(new Set([...(words || []).slice(0, 64), ...expanded]));
+                seeds = this.mapWordsToMemes(merged);
+            }
+        }
+        result = result || this.runPropagation(seeds, { iteration, radius });
         const reply = this.composeReply(result, words, seeds);
         const latency = Date.now() - started;
         this.metrics.requests += 1;
@@ -1895,7 +2855,8 @@ class RuntimeState {
         }
 
         const seeds = this.mapWordsToMemes(tokens);
-        const memeIds = Array.from(seeds.keys());
+        // 使用有序“词结构/短语结构”序列建边（从句子级细化到词/短语级）
+        const memeIds = this._buildMemeSequenceFromTokens(tokens);
         for (let i = 0; i < memeIds.length - 1; i++) {
             this.graph.link(memeIds[i], memeIds[i + 1], 1, 0);
         }
@@ -1925,7 +2886,12 @@ class RuntimeState {
         if (!this.robotsCorpus) {
             this.robotsCorpus = new RobotsCorpus({
                 dir: this.config.robotsDir,
-                lemmaCsv: this.config.lemmaCsv
+                lemmaCsv: this.config.lemmaCsv,
+                lemmaAutoload: this.config.lemmaAutoload,
+                lemmaMaxBytes: this.config.lemmaMaxBytes,
+                lemmaForce: this.config.lemmaForce,
+                chunkMinWords: this.config.robotsChunkMinWords,
+                chunkMaxWords: this.config.robotsChunkMaxWords
             });
         }
         return this.robotsCorpus;
@@ -1981,7 +2947,9 @@ class RuntimeState {
             params: this.params,
             graph: this.graph.exportSnapshot(),
             sessions: this.sessions.export(),
-            kvm: this.kvm.exportEntries()
+            kvm: this.kvm.exportEntries(),
+            surface: this.surfaceLexicon ? this.surfaceLexicon.exportSnapshot({ limitMemes: 512 }) : null,
+            dialog: this.dialogMemory ? this.dialogMemory.exportSnapshot({ limit: 512 }) : null
         };
     }
 
@@ -1999,6 +2967,12 @@ class RuntimeState {
                 }
             }
         }
+        if (snapshot.surface && this.surfaceLexicon) {
+            this.surfaceLexicon.importSnapshot(snapshot.surface);
+        }
+        if (snapshot.dialog && this.dialogMemory) {
+            this.dialogMemory.importSnapshot(snapshot.dialog);
+        }
     }
 
     // 将当前窗口或指定种子集合导出为 Go 侧 Graph 结构并写入文件
@@ -2266,11 +3240,19 @@ class StudyEngine {
         this.running = false;
         this.queue = [];
         this.metrics = { enqueued: 0, processed: 0, lastTickAt: 0, lastError: null };
+        this.poolWorker = null;
+    }
+
+    _ensureWorkerPool() {
+        if (this.poolWorker) {
+            return this.poolWorker;
+        }
         this.poolWorker = workerpool.pool(CONFIG.workerFile, {
             minWorkers: 1,
             maxWorkers: CONFIG.maxWorkers,
             workerType: 'process'
         });
+        return this.poolWorker;
     }
 
     start() {
@@ -2301,7 +3283,8 @@ class StudyEngine {
             try {
                 const text = String(doc?.text || '');
                 const tokens = tokenize(text);
-                await this.poolWorker.exec('batchLemmatize', [[tokens], this.pool.getActive().runtime?.config?.lemmaCsv]);
+                const wp = this._ensureWorkerPool();
+                await wp.exec('batchLemmatize', [[tokens], this.pool.getActive().runtime?.config?.lemmaCsv]);
             } catch (_e) {
                 // ignore
             }
@@ -2701,6 +3684,66 @@ class PersonaForestAverager {
     }
 }
 
+const normalizeBudget = (raw) => {
+    if (raw === undefined || raw === null || raw === '' || raw === false) {
+        return null;
+    }
+    if (typeof raw === 'string') {
+        const s = raw.trim();
+        const lowered = s.toLowerCase();
+        if (lowered === 'default' || lowered === 'balanced' || lowered === 'medium' || lowered === 'none') {
+            return null;
+        }
+        if (lowered === 'low' || lowered === 'fast') {
+            return { iteration: 3, reflectionTopMemes: 12, reflectionTopWords: 16 };
+        }
+        if (lowered === 'high' || lowered === 'slow' || lowered === 'quality') {
+            return { iteration: 7, reflectionTopMemes: 22, reflectionTopWords: 32 };
+        }
+        if (s.startsWith('{') && s.endsWith('}')) {
+            try {
+                return normalizeBudget(JSON.parse(s));
+            } catch (_e) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+    if (typeof raw !== 'object') {
+        return null;
+    }
+    const out = {};
+    const pickNum = (key, ...aliases) => {
+        const v = raw[key];
+        if (Number.isFinite(Number(v))) {
+            out[key] = Number(v);
+            return;
+        }
+        for (const a of aliases) {
+            const av = raw[a];
+            if (Number.isFinite(Number(av))) {
+                out[key] = Number(av);
+                return;
+            }
+        }
+    };
+    pickNum('mappingDepth', 'depth');
+    pickNum('iteration', 'iters');
+    pickNum('reflectionTopMemes', 'topMemes');
+    pickNum('reflectionTopWords', 'topWords');
+    pickNum('reflectionMinScore', 'minScore');
+    pickNum('radius', 'windowRadius');
+    return Object.keys(out).length ? out : null;
+};
+
+const mergeBudgets = (base, override) => {
+    if (!base && !override) return null;
+    if (!base) return override;
+    if (!override) return base;
+    return { ...base, ...override };
+};
+
 class SparkArray {
     /**
      * @param {ControllerPool} pool
@@ -2716,9 +3759,10 @@ class SparkArray {
         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 wantedRaw = options.numAI ?? options.groupSize ?? CONFIG.sparkNumAI ?? CONFIG.groupSize ?? 7;
+        const wanted = Math.max(1, Math.round(Number(wantedRaw) || 7));
         const numAI = Math.max(1, Math.min(available.length || wanted, wanted));
-        // 组内小 SparkArray：固定 7 个 AI（不足则截断）
+        // 组内小 SparkArray：默认 numAI 个 AI（不足则截断）
         this.layers = Array.from({ length: numAI }, (_, i) => ({
             name: `${this.groupId}:a${i + 1}`,
             controllers: [available[i]],
@@ -2729,6 +3773,7 @@ class SparkArray {
             this.layers = options.layers.map((layer) => ({ strategy: 'max', ...layer }));
         }
         this.personaForest = new PersonaForestAverager(options.personaForest || {});
+        this.defaultBudget = normalizeBudget(options.budget ?? CONFIG.sparkBudget);
         this.history = [];
     }
 
@@ -2751,9 +3796,15 @@ class SparkArray {
     async dispatch(payload, options = {}) {
         const requestEmbedding = textToMiniEmbedding(payload.text || '', 64);
         const variants = buildVariants(payload.text || '', options.perturbations || 0);
-        const layers = options.multiLayer === false ? [this.layers[0]] : this.layers;
+        let layers = options.multiLayer === false ? [this.layers[0]] : this.layers;
+        if (Number.isFinite(Number(options.numAI)) && Number(options.numAI) > 0) {
+            const cap = Math.max(1, Math.floor(Number(options.numAI)));
+            layers = layers.slice(0, cap);
+        }
         const layerResults = [];
 
+        const budget = mergeBudgets(this.defaultBudget, normalizeBudget(options.budget ?? payload?.budget));
+
         for (const layer of layers) {
             const controllers = [];
             for (const controllerSpec of layer.controllers) {
@@ -2773,7 +3824,7 @@ class SparkArray {
                     const weightedText = weight <= 1
                         ? String(payload.text || '')
                         : Array.from({ length: weight }, () => String(payload.text || '')).join(' ');
-                    baseResult = await ctrl.respond({ ...payload, text: weightedText });
+                    baseResult = await ctrl.respond({ ...payload, text: weightedText, ...(budget ? { budget } : {}) });
                 } catch (err) {
                     controllers.push({
                         controller: controllerName,
@@ -2786,7 +3837,7 @@ class SparkArray {
                 const variantResults = [];
                 for (const variant of variants) {
                     try {
-                        const vr = await ctrl.respond({ ...payload, text: variant });
+                        const vr = await ctrl.respond({ ...payload, text: variant, ...(budget ? { budget } : {}) });
                         variantResults.push({
                             text: variant,
                             response: vr,
@@ -2855,7 +3906,7 @@ class SparkArray {
                 }
             }
         }
-
+        
         // 随机森林式“中途平均/投票”：在不改变对外结构的前提下，优先选择更稳定且共识更强的回复
         try {
             const picked = this.personaForest.pick({
@@ -3160,7 +4211,7 @@ class ReinforcementLearner {
         this.improvementThreshold = improvementThreshold;
         this.history = [];
         // 统一使用上方安全引用的 Matrix（可能为 null）
-        this.Matrix = Matrix;
+        this.Matrix = getMatrix();
         this.kmeans = safeRequire('ml-kmeans');
         this.numeric = safeRequire('numeric');
     }
@@ -3353,7 +4404,7 @@ class AdversarialLearner {
         this.benchLimit = benchLimit;
         this.rng = safeRequire('seedrandom') ? safeRequire('seedrandom')('phoenix-adv') : Math.random;
         this.history = [];
-        this.Matrix = safeRequire('ml-matrix');
+        this.Matrix = getMatrix();
     }
 
     _perturbTokens(tokens) {
@@ -3491,8 +4542,8 @@ class GatewayServer {
         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.rl = learners.rl || null;
+        this.adv = learners.adv || null;
         this.rlDisabled = false;
         this.advDisabled = false;
         this.dialogLearningEnabled = true;
@@ -3556,6 +4607,18 @@ class GatewayServer {
         this._setupRoutes();
     }
 
+    _ensureRL() {
+        if (this.rl) return this.rl;
+        this.rl = new ReinforcementLearner(this.pool, { testsDir: path.join(__dirname, 'tests') });
+        return this.rl;
+    }
+
+    _ensureADV() {
+        if (this.adv) return this.adv;
+        this.adv = new AdversarialLearner(this.pool, {});
+        return this.adv;
+    }
+
     _setupAuthMiddleware() {
         let jwt;
         try {
@@ -3767,14 +4830,14 @@ class GatewayServer {
                     return;
                 }
                 const cycles = Number(req.body?.cycles ?? 3) || 3;
-                const out = await this.rl.learn(cycles);
+                const out = await this._ensureRL().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() });
+            res.json({ ok: true, latest: this.rl ? this.rl.latest() : null });
         });
         // Adversarial Learning endpoints
         this.app.post('/api/learn/adversarial', async (req, res) => {
@@ -3788,14 +4851,14 @@ class GatewayServer {
                     res.status(400).json({ ok: false, error: 'samples required' });
                     return;
                 }
-                const out = await this.adv.attackAndDefend(samples);
+                const out = await this._ensureADV().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() });
+            res.json({ ok: true, latest: this.adv ? this.adv.latest() : null });
         });
         this.app.post('/api/learn/thresholds', (req, res) => {
             const { rlEvery, advEvery } = req.body || {};
@@ -3885,6 +4948,8 @@ class GatewayServer {
                 config: {
                     groupCount: CONFIG.groupCount,
                     groupSize: CONFIG.groupSize,
+                    sparkNumAI: CONFIG.sparkNumAI,
+                    sparkBudget: CONFIG.sparkBudget,
                     groupIds: typeof this.pool.listGroupIds === 'function' ? this.pool.listGroupIds() : [],
                     gatewayHost: CONFIG.gatewayHost,
                     portGateway: CONFIG.portGateway,
@@ -4336,9 +5401,21 @@ class GatewayServer {
             if (!this.dialogLearningEnabled) {
                 return;
             }
+
+            // 反接学习：把本轮对话沉淀为“模因层 -> 表层答案”的映射与可检索记忆
+            try {
+                const runtime = this.pool?.getActive?.()?.runtime;
+                if (runtime && typeof runtime.learnFromDialog === 'function') {
+                    runtime.learnFromDialog({ payload, result });
+                }
+            } catch (e) {
+                // 学习失败不影响主流程
+                console.warn('[Learn] surface/dialog memory update failed:', e.message);
+            }
+
             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));
+                Promise.resolve().then(() => this._ensureRL().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;
@@ -4347,7 +5424,7 @@ class GatewayServer {
                 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));
+                    Promise.resolve().then(() => this._ensureADV().attackAndDefend(samples)).catch((e) => console.warn('[Learn] ADV trigger failed:', e.message));
                 }
             }
         } catch (e) {
@@ -4363,9 +5440,9 @@ class GatewayServer {
 }
 
 const bootstrap = async () => {
-    const kvmStore = new LmdbStore({ name: 'kvm', rootDir: CONFIG.lmdbRoot });
-    const memeStore = new LmdbStore({ name: 'meme_graph', rootDir: CONFIG.lmdbRoot });
-    const sessionStore = new LmdbStore({ name: 'session', rootDir: CONFIG.lmdbRoot });
+    const kvmStore = new LmdbStore({ name: 'kvm', rootDir: CONFIG.lmdbRoot, mapSizeBytes: CONFIG.lmdbMapSizeBytes });
+    const memeStore = new LmdbStore({ name: 'meme_graph', rootDir: CONFIG.lmdbRoot, mapSizeBytes: CONFIG.lmdbMapSizeBytes });
+    const sessionStore = new LmdbStore({ name: 'session', rootDir: CONFIG.lmdbRoot, mapSizeBytes: CONFIG.lmdbMapSizeBytes });
     console.log('checkpoint1');
     const pool = new ControllerPool({ kvmStore, memeStore, sessionStore, config: CONFIG });
     const rotation = new RotationManager(pool, {});
@@ -4380,19 +5457,33 @@ const bootstrap = async () => {
     study.start();
     const snapshots = new SnapshotManager(pool.getActive().runtime, CONFIG.snapshotDir);
     const shards = new ShardManager(pool);
-    const spark = new BigSparkArray(pool, shards, { groupIds: pool.listGroupIds() });
+    const spark = new BigSparkArray(pool, shards, {
+        groupIds: pool.listGroupIds(),
+        groupOptions: {
+            numAI: CONFIG.sparkNumAI,
+            budget: CONFIG.sparkBudget
+        }
+    });
     // 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]);
+            const restoredSnapshot = 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);
+            if (CONFIG.syncStandbyOnBoot) {
+                // 注意：applySnapshot 内部包含大量同步写入，依然会阻塞；仅在你明确需要时开启。
+                try {
+                    await pool.standby.applySnapshot(restoredSnapshot);
+                    await pool.validation.applySnapshot(restoredSnapshot);
+                    console.log('[Bootstrap] Standby/validation synced from snapshot');
+                } catch (e) {
+                    console.warn('[Bootstrap] Standby/validation sync skipped:', e.message);
+                }
+            } else {
+                console.log('[Bootstrap] Standby/validation sync skipped (fast-boot)');
+            }
         }
     } catch (err) {
         console.warn('[Bootstrap] Snapshot restore skipped:', err.message);
@@ -4401,7 +5492,7 @@ const bootstrap = async () => {
         try {
             const preloadDocs = pool.getActive().runtime.collectRobotsDocuments({
                 limit: CONFIG.robotsWarmupLimit,
-                shuffle: true
+                shuffle: Boolean(CONFIG.robotsWarmupShuffle)
             });
             if (preloadDocs.length) {
                 console.log(`[Bootstrap] Preloading ${preloadDocs.length} robots documents...`);
@@ -4423,64 +5514,60 @@ const bootstrap = async () => {
     }
 
     // 额外：将 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 });
+    if (CONFIG.testsAutoload) {
+        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) {
+                    console.log(`[Bootstrap] Preloading tests corpus (${files.length} files)...`);
+                    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.`);
                 }
-                console.log(`[Bootstrap] Sharded tests corpus into ${groups.length} groups.`);
             }
+        } catch (err) {
+            console.warn('[Bootstrap] Tests sharded preload skipped:', err.message);
         }
-    } catch (err) {
-        console.warn('[Bootstrap] Tests sharded preload skipped:', err.message);
+    } else {
+        console.log('[Bootstrap] Tests preload skipped (fast-boot)');
     }
-    // 初始化学习模块
-    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 });
+    // 学习模块改为网关侧按需创建（降低启动时间与内存峰值）
+    const gateway = new GatewayServer(pool, shards, snapshots, rotation, redisSync, study, spark, { rl: null, adv: null });
     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 (_) {}
+    // 可选预热：默认关闭；需要时加 --learning-warmup=true
+    if (CONFIG.learningWarmup) {
+        (async () => {
+            if (!CONFIG.disableLearning && !CONFIG.disableRL) {
+                try {
+                    await gateway._ensureRL().learn(1);
+                } catch (e) {
+                    console.warn('[Bootstrap] RL warmup failed:', e.message);
+                    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);
+
+            if (!CONFIG.disableLearning && !CONFIG.disableADV) {
+                try {
+                    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 gateway._ensureADV().attackAndDefend(samples);
+                    }
+                } catch (e) {
+                    console.warn('[Bootstrap] Adversarial warmup failed:', e.message);
                 }
-            } 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 {
@@ -4502,5 +5589,8 @@ if (require.main === module) {
 
 module.exports = {
     bootstrap,
-    CONFIG
+    CONFIG,
+    MODEL_DEFAULTS: modelDefaults,
+    BUILTIN_ACTIVATION_TYPES: Object.keys(BuiltinActivations),
+    BUILTIN_TRANSFER_TYPES: Object.keys(BuiltinTransfers)
 };