lume-dsh-plugin 0.4.1

package/lib/core/card.js

@@ -0,0 +1,101 @@
+/**
+ * 人设卡导出/导入的纯函数层：序列化、解析与归一化。
+ *
+ * 卡片格式：自包含 JSON，含契约 + 语料 + 风格约定 + 记忆（可选）+ 签名。
+ * 导入侧校验键名合法性、内置名保护、字段截断上限，但不对 promptText
+ * 做语义校验（那是蒸馏管线的职责）。
+ */
+import { BUILTIN_PERSONA_NAMES, CORPUS_CAP, CORPUS_LINE_CAP, MEMORY_CAP, STYLE_CAP, sanitizeCorpus } from "../host/identity.js";
+export const CARD_FORMAT = "lume-persona-card";
+export const CARD_VERSION = 1;
+/** 序列化一张卡片。 */
+export function serializeCard(bundle) {
+    return JSON.stringify(bundle, null, 2) + "\n";
+}
+/** 解析一段 JSON 文本；结构/格式/版本不合法返回带 error 的 ParseErr。 */
+export function parseCard(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, error: "JSON 解析失败：文件不是合法的 JSON。" };
+    }
+    if (typeof raw !== "object" || raw === null) {
+        return { ok: false, error: "卡片格式错误：根节点必须是对象。" };
+    }
+    const r = raw;
+    if (r.format !== CARD_FORMAT) {
+        return { ok: false, error: `不支持的文件格式：期望 "${CARD_FORMAT}"，实际 "${String(r.format)}"。` };
+    }
+    if (typeof r.version !== "number" || r.version !== CARD_VERSION) {
+        return { ok: false, error: `不支持的卡片版本：期望 ${CARD_VERSION}，实际 ${String(r.version)}。` };
+    }
+    const p = r.persona;
+    if (typeof p !== "object" || p === null) {
+        return { ok: false, error: "卡片缺少 persona 字段。" };
+    }
+    const persona = p;
+    if (typeof persona.name !== "string" || !persona.name) {
+        return { ok: false, error: "卡片 persona.name 为空或不是字符串。" };
+    }
+    if (typeof persona.displayName !== "string" || !persona.displayName) {
+        return { ok: false, error: "卡片 persona.displayName 为空或不是字符串。" };
+    }
+    if (typeof persona.promptText !== "string" || !persona.promptText) {
+        return { ok: false, error: "卡片 persona.promptText 为空或不是字符串。" };
+    }
+    return {
+        ok: true,
+        value: {
+            format: CARD_FORMAT,
+            version: CARD_VERSION,
+            persona: {
+                name: persona.name,
+                displayName: persona.displayName,
+                description: typeof persona.description === "string" ? persona.description : "",
+                promptText: persona.promptText,
+                corpus: sanitizeCorpus(persona.corpus),
+                profileName: typeof persona.profileName === "string" && persona.profileName ? persona.profileName : null,
+                styleRules: Array.isArray(persona.styleRules)
+                    ? persona.styleRules
+                        .filter((r) => typeof r?.rule === "string" && r.rule)
+                        .slice(-STYLE_CAP)
+                    : [],
+                memory: Array.isArray(persona.memory)
+                    ? persona.memory
+                        .filter((m) => typeof m?.text === "string" && m.text)
+                        .slice(-MEMORY_CAP)
+                    : undefined,
+                signatureWords: Array.isArray(persona.signatureWords) ? persona.signatureWords.filter((w) => typeof w === "string" && w.length > 0) : undefined,
+            },
+        },
+    };
+}
+/**
+ * 归一化并校验：键名合法性、内置名保护、字段截断。
+ * 拒绝覆盖内置人设；返回规范化后的卡片（供导入写入）。
+ */
+export function normalizeCard(card) {
+    const name = card.name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        return { ok: false, error: `人设键名 "${name}" 不合法：必须以小写字母开头，只含小写字母/数字/连字符。` };
+    }
+    if (BUILTIN_PERSONA_NAMES.has(name)) {
+        return { ok: false, error: `"${name}" 是内置人设，不可覆盖。` };
+    }
+    return {
+        ok: true,
+        value: {
+            name,
+            displayName: card.displayName.trim().slice(0, 12),
+            description: (card.description ?? "").trim().slice(0, 60),
+            promptText: card.promptText.trim().slice(0, 2000),
+            corpus: sanitizeCorpus(card.corpus),
+            profileName: card.profileName?.trim() || null,
+            styleRules: (card.styleRules ?? []).slice(-STYLE_CAP),
+            memory: card.memory?.slice(-MEMORY_CAP),
+            signatureWords: card.signatureWords,
+        },
+    };
+}

package/lib/core/dialogue-mining.js

@@ -0,0 +1,409 @@
+/**
+ * 对话挖掘（纯函数层）：从小说/剧本/设定文档等素材里抽取目标角色的台词样本
+ * 与叙述线索。蒸馏管线的第 0 步，零 token 成本；产出交给 LLM 做契约与语料合成。
+ *
+ * 两种素材形态：
+ * - 剧本行（`角色名：台词`）——归属明确，直接按名字统计；
+ * - 小说引号台词（「…」「…」）——用引号前的「XX说/道/问」归属；归属线索不足时
+ *   （设定文档/独白类素材）视为单一声音，全部台词归目标角色。
+ */
+export const MAX_MINED_LINES = 48;
+export const MAX_OTHER_LINES = 12;
+export const NARRATIVE_CAP = 1600;
+export const MIN_SCRIPT_LINES = 3;
+/** 引号台词：中文直角/弯引号 + 英文双引号。 */
+const QUOTE_RE = /[「『“"]([^」』”"]{2,120})[」』”"]/g;
+/** 剧本行：行首（可带 - • 序号）短名字 + 冒号 + 台词。 */
+const SCRIPT_LINE_RE = /^\s*(?:[-*•]\s*)?(?:\d+[.、]\s*)?([^\s：:，。！？、"'「」『』()（）]{1,12})\s*[：:]\s*(\S.{1,200})$/;
+/** 说话引导动词：引号前窗口内的归属线索。捕获组是动作发出者；代词不算有效归属。
+ * 名字组非贪婪 + 复合动词（又问/再说等）入表，保证「噜噜又问」解析为 名字=噜噜 动词=又问。 */
+const SAID_RE = /([\u4e00-\u9fffA-Za-z0-9·]{1,8}?)(?:小声道|轻声道|冷冷道|淡淡地?道|笑道|哭道|喊道|问道|答道|说道|叫道|骂道|嘀咕|嘟囔|反驳道?|回答道?|补充道?|开口道?|低声道?|追问|反问道?|又问|又说|又道|再说|再道|接着说|接着道|道|说|问|喊)/;
+const PRONOUNS = new Set(["她", "他", "它", "你", "我"]);
+/** 均匀取样：n 超限时按索引等距抽取，保持时序。 */
+function evenSample(items, n) {
+    if (items.length <= n)
+        return items;
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        out.push(items[Math.floor((i * items.length) / n)]);
+    }
+    return out;
+}
+/** 剧本行挖掘。 */
+function mineScriptLines(text) {
+    const out = [];
+    for (const raw of text.split("\n")) {
+        const match = SCRIPT_LINE_RE.exec(raw);
+        if (match)
+            out.push({ speaker: match[1].trim(), line: match[2].trim() });
+    }
+    return out;
+}
+/** 归属窗口：引号开始处往前的字符数 / 引号结束处往后的字符数。 */
+const ATTRIBUTION_WINDOW = 30;
+const POST_ATTRIBUTION_WINDOW = 12;
+/** 名字有效性：代词（含代词开头的误捕获，如「她淡淡」）不算说话人。 */
+function cleanName(raw) {
+    return raw && !PRONOUNS.has(raw[0]) ? raw.trim() : null;
+}
+/**
+ * 引号台词挖掘 + 归属（汉语小说惯例）：
+ * - 「X说：」紧贴引号前且带冒号 → 描述当前引号；
+ * - 「…」X笑道 紧贴引号后 → 描述当前引号；
+ * - 两引号之间的裸标签（无冒号）属于前一个引号，不算当前归属。
+ */
+function mineQuotedLines(text) {
+    const out = [];
+    let prevEnd = 0;
+    for (const match of text.matchAll(QUOTE_RE)) {
+        const line = match[1].trim();
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        let speaker = null;
+        const preWindow = text.slice(Math.max(prevEnd, start - ATTRIBUTION_WINDOW), start);
+        const pre = SAID_RE.exec(preWindow);
+        if (pre) {
+            const afterVerb = preWindow.slice(pre.index + pre[0].length, pre.index + pre[0].length + 1);
+            if (afterVerb === "：" || afterVerb === ":")
+                speaker = cleanName(pre[1]);
+        }
+        // 前窗没有「X说：」形态时，再看引号后是否紧跟「X笑道」——两个来源独立尝试
+        if (!speaker) {
+            const post = SAID_RE.exec(text.slice(end, end + POST_ATTRIBUTION_WINDOW));
+            if (post)
+                speaker = cleanName(post[1]);
+        }
+        out.push({ speaker, line });
+        prevEnd = end;
+    }
+    return out;
+}
+function countBySpeaker(lines) {
+    const counts = new Map();
+    for (const { speaker } of lines) {
+        if (!speaker)
+            continue;
+        counts.set(speaker, (counts.get(speaker) ?? 0) + 1);
+    }
+    return counts;
+}
+function topSpeaker(counts, hint) {
+    if (hint) {
+        const wanted = [...counts.keys()].find((name) => name === hint.trim() || name.includes(hint.trim()) || hint.trim().includes(name));
+        if (wanted)
+            return wanted;
+    }
+    let best = null;
+    let bestCount = 0;
+    for (const [name, count] of counts) {
+        if (count > bestCount) {
+            best = name;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+/** 台词剥离 → 压缩空白 → 截断。 */
+function condenseNarrative(text, cap = NARRATIVE_CAP) {
+    const stripped = text.replace(QUOTE_RE, "□").replace(/[ \t]+/g, " ");
+    const lines = stripped
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    let out = "";
+    for (const line of lines) {
+        if (out.length + line.length + 1 > cap)
+            break;
+        out += (out ? "\n" : "") + line;
+    }
+    return out;
+}
+// ── 聊天记录解析（微信/QQ 导出格式）─────────────────────────────────────
+//
+// 微信「多选→复制」与第三方导出工具的常见形态：
+//   昵称A
+//   2026年08月31日 00:40
+//   消息内容（可能多行）
+//
+//   昵称B
+//   2026年08月31日 00:41
+//   [语音] 3" / [图片] xxx.jpg / [动画表情] / [无语] / 
+//
+// 结构特征：每个昵称独占一行，紧跟时间戳行。时间戳行是可靠的分块锚点，
+// 据此可以切出「谁 → 说了什么」。导出不含「谁是自己」的标记——目标说话人
+// 由 UI 点选（hint）传入，其余全部归为用户侧。
+/** 聊天记录时间戳行：2026年08月31日 00:40（也兼容 2026-08-31 00:40）。 */
+const CHAT_TS_RE = /^\d{4}[-年]\d{1,2}[-月]\d{1,2}日?\s+\d{1,2}:\d{2}/;
+/** 非文本消息占位：[语音] 3" / [图片] 微信图片_xxx.jpg / [动画表情]。 */
+const CHAT_PLACEHOLDER_RE = /^\[(语音|图片|视频|动画表情|表情|文件|链接|转账|红包|位置|名片|小程序|引用|音乐|语音通话|视频通话|接龙|笔记|收藏)/;
+/** 纯方括号短占位（QQ 表情名如 [无语]、[捂脸]）。 */
+const CHAT_EMOJI_RE = /^\[[^\]\s]{1,8}\]$/;
+/** 对象替换符（微信复制时图片/表情的残留）。 */
+const OBJ_REPLACEMENT = "\uFFFC";
+/**
+ * 解析聊天记录导出文本。识别不出聊天结构（时间戳锚点不足 / 说话人单一）
+ * 返回 null——调用方回退到小说/剧本挖掘。
+ *
+ * 结构锚点：说话人独占一行，紧跟时间戳行。解析用前瞻——若某行的下一行是
+ * 时间戳，则该行是说话人，内容从再下一行起，直到下一个说话人行。
+ */
+export function parseChatLog(text) {
+    const lines = text.split("\n");
+    const messages = [];
+    const counts = new Map();
+    let i = 0;
+    while (i < lines.length - 1) {
+        // 前瞻：下一行是时间戳 → 当前行是说话人
+        if (!CHAT_TS_RE.test(lines[i + 1].trim())) {
+            i++;
+            continue;
+        }
+        const speaker = lines[i].trim();
+        if (!speaker) {
+            i++;
+            continue;
+        }
+        const timestamp = lines[i + 1].trim();
+        const content = [];
+        let j = i + 2;
+        while (j < lines.length) {
+            // 下一行若是时间戳且当前行非空 → 新的说话人行，内容到此为止
+            if (j + 1 < lines.length && lines[j].trim() && CHAT_TS_RE.test(lines[j + 1].trim()))
+                break;
+            content.push(lines[j]);
+            j++;
+        }
+        const cleaned = cleanChatContent(content);
+        if (cleaned) {
+            messages.push({ speaker, text: cleaned, timestamp });
+            counts.set(speaker, (counts.get(speaker) ?? 0) + 1);
+        }
+        i = j;
+    }
+    if (messages.length < 4 || counts.size < 2)
+        return null;
+    const speakers = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([name]) => name);
+    return { messages, speakers };
+}
+/** 清洗一条消息的原始行：剔除占位符、对象替换符、空行，合并多行。 */
+function cleanChatContent(lines) {
+    const kept = [];
+    for (const raw of lines) {
+        const line = raw.replaceAll(OBJ_REPLACEMENT, "").trim();
+        if (!line)
+            continue;
+        if (CHAT_PLACEHOLDER_RE.test(line))
+            continue;
+        if (CHAT_EMOJI_RE.test(line))
+            continue;
+        kept.push(line);
+    }
+    return kept.join(" ").trim();
+}
+/** 聊天记录模式挖掘：目标说话人（hint 或最高频）为台词主源，其余归用户侧。 */
+export function mineChatLog(chat, hint) {
+    const target = hint?.trim() ? (chat.speakers.find((s) => s === hint.trim() || s.includes(hint.trim()) || hint.trim().includes(s)) ?? null) : null;
+    const speaker = target ?? chat.speakers[0] ?? null;
+    const targetLines = chat.messages.filter((m) => m.speaker === speaker).map((m) => m.text);
+    const otherLines = chat.messages.filter((m) => m.speaker !== speaker).map((m) => m.text);
+    // 真实对话对：允许用户连续发多条时，合并成一个上下文，避免只保留最后一句。
+    const pairs = [];
+    let pendingUser = [];
+    let pendingAt;
+    const toMillis = (stamp) => {
+        if (!stamp)
+            return null;
+        const normalized = stamp.replace(/年|月/g, "-").replace(/日/g, "");
+        const value = Date.parse(normalized.replace(/\s+/g, "T"));
+        return Number.isFinite(value) ? value : null;
+    };
+    for (const m of chat.messages) {
+        if (m.speaker === speaker) {
+            const gap = pendingAt && m.timestamp ? (toMillis(m.timestamp) - toMillis(pendingAt)) : null;
+            // 超过 6 小时视为新话题，不能把前一天的闲聊拼成当前回复的上下文。
+            if (pendingUser.length > 0 && m.text.length <= 240 && (gap === null || (gap >= 0 && gap <= 6 * 60 * 60 * 1000))) {
+                pairs.push({ user: pendingUser.join(" ").slice(-240), assistant: m.text });
+            }
+            pendingUser = [];
+            pendingAt = undefined;
+        }
+        else {
+            if (pendingUser.length === 0)
+                pendingAt = m.timestamp;
+            pendingUser.push(m.text);
+        }
+    }
+    // 契约不能只看目标单边台词：保留每条目标消息前后的小窗口，学习触发条件、
+    // 关系距离和情绪转折。窗口只进蒸馏 prompt，不会污染最终 few-shot 语料。
+    const targetIndexes = chat.messages.map((m, i) => m.speaker === speaker ? i : -1).filter((i) => i >= 0);
+    const contexts = [];
+    for (const i of evenSample(targetIndexes, 16)) {
+        const start = Math.max(0, i - 3);
+        const end = Math.min(chat.messages.length, i + 2);
+        const window = chat.messages.slice(start, end).map((m) => `${m.speaker === speaker ? "目标" : "用户"}：${m.text}`).join("\n");
+        contexts.push(window.slice(0, 700));
+    }
+    const targetTexts = targetLines;
+    const lengths = targetTexts.map((s) => s.length);
+    const avg = lengths.length ? Math.round(lengths.reduce((a, b) => a + b, 0) / lengths.length) : 0;
+    const sorted = [...lengths].sort((a, b) => a - b);
+    const median = sorted.length ? sorted[Math.floor(sorted.length / 2)] : 0;
+    const punct = (re) => targetTexts.reduce((n, s) => n + (s.match(re)?.length ?? 0), 0);
+    const emojiCount = punct(/[😀-🙏🌀-🫿]/gu);
+    const questionCount = punct(/[？?]/g);
+    const exclaimCount = punct(/[！!]/g);
+    const ellipsisCount = punct(/[…。]{2,}|\.\.\./g);
+    const stats = `样本数 ${targetTexts.length}；平均 ${avg} 字；中位数 ${median} 字；含问号 ${questionCount} 条；含感叹号 ${exclaimCount} 条；含省略号 ${ellipsisCount} 条；emoji 总数 ${emojiCount}。`;
+    // 记忆点候选：真实事件类消息（生日/纪念/共同经历/对方的事实/约定）
+    const memoryPoints = chat.messages
+        .filter((m) => MEMORY_EVENT_RE.test(m.text))
+        .map((m) => m.text.slice(0, 160))
+        .slice(0, 12);
+    // 关系称呼：双方谁扮演什么角色。微信「备注名/对方昵称」本身即关系线索——
+    // 用户给 TA 的备注是「老公」→ 用户叫 TA 老公（userToTarget）；TA 对用户的称呼
+    // 只能看 TA 消息里的称呼词（「老婆，…」）。消息内容中的称呼词同样计入另一侧。
+    const otherSpeakers = chat.speakers.filter((s) => s !== speaker);
+    const userLines = chat.messages.filter((m) => m.speaker !== speaker).map((m) => m.text);
+    const targetLinesAll = targetLines;
+    const greetingOf = (text) => {
+        if (!text)
+            return null;
+        for (const word of RELATION_WORDS) {
+            if (text.includes(word))
+                return word;
+        }
+        return null;
+    };
+    // 用户给目标的备注（如「老公」）= 用户如何称呼目标；目标消息里的称呼词（如「老婆」）= 目标如何称呼用户
+    const userToTarget = [...new Set([...RELATION_WORDS.filter((w) => speaker !== null && speaker.includes(w)), ...userLines.map(greetingOf).filter((w) => Boolean(w))])].slice(0, 6);
+    const targetToUser = [...new Set(targetLinesAll.map(greetingOf).filter((w) => Boolean(w)))].slice(0, 6);
+    const relationship = { userToTarget, targetToUser };
+    return {
+        speaker,
+        lines: evenSample(targetLines, MAX_MINED_LINES),
+        otherLines: evenSample(otherLines, MAX_OTHER_LINES),
+        narrative: "",
+        kind: "chat",
+        mixed: false,
+        // 不取最早的 12 组：按时间均匀覆盖全聊天，避免语料被开头某个话题垄断。
+        pairs: evenSample(pairs, 12),
+        contexts,
+        styleStats: stats,
+        memoryPoints,
+        relationship,
+        flow: buildChatFlow(chat.messages, speaker),
+    };
+}
+/** 关系称呼词：出现在对话中即揭示双方关系定位。 */
+const RELATION_WORDS = [
+    "老公", "老婆", "媳妇", "弟妹", "宝宝", "宝贝", "亲爱的",
+    "爸爸", "妈妈", "爸", "妈", "爹", "娘",
+    "哥", "姐", "弟", "妹", "哥哥", "姐姐", "弟弟", "妹妹",
+    "师傅", "师父", "老板", "同事", "闺蜜", "兄弟", "哥们", "姐妹",
+    "女神", "男神", "前男/女友", "前男友", "前女友",
+];
+/** 真实事件信号：生日/纪念/年份/岁数/共同经历/对方身份事实/约定。 */
+const MEMORY_EVENT_RE = /生日|纪念|周年|过完生日|周岁|去[^。，]{0,12}(过|去|玩|旅游)|第一次|那一年|去年|前年|过年|春节|中秋|国庆|跨年|毕业|结婚|认识[^。，]{0,10}年|领养|搬[^。，]{0,6}家|换工作|辞职|入职|生[了过][^。，]{0,8}(孩子|小孩|女儿|儿子)|考[上完研][^。，]{0,8}|我做|我是[^。，]{0,10}(医生|老师|老师|程序员|设计师)|我[在学过][^。，]{0,10}(编程|画画|钢琴|吉他)/;
+export const MEMORY_POINT_CAP = 12;
+/** 对话流单条消息字数上限（超限截断，保留开头）。 */
+const FLOW_LINE_CAP = 160;
+/** 对话流总字数预算：聊天记录可达 20 万字，记忆提炼 prompt 吃不下全文；
+ * 超出时按「一问一答」成对等距抽样，事件信号消息必留，保证关键事实不丢。 */
+const FLOW_CHAR_BUDGET = 6000;
+/**
+ * 构建记忆提炼用的完整对话流：双方消息按时间顺序、带归属（me）保留。
+ * 抽样策略：事件信号消息（生日/入职/搬家…）一律保留；其余消息在超预算时
+ * 按「一方的消息 + 紧随的另一方消息」成对等距抽取，保住一问一答的语境。
+ */
+function buildChatFlow(messages, target) {
+    const tagged = messages.map((m) => ({
+        me: m.speaker === target,
+        text: m.text.length > FLOW_LINE_CAP ? m.text.slice(0, FLOW_LINE_CAP) + "…" : m.text,
+        event: MEMORY_EVENT_RE.test(m.text),
+    }));
+    const total = tagged.reduce((sum, m) => sum + m.text.length, 0);
+    if (total <= FLOW_CHAR_BUDGET)
+        return tagged.map(({ me, text }) => ({ me, text }));
+    const keep = new Set();
+    let eventChars = 0;
+    tagged.forEach((m, i) => {
+        if (m.event) {
+            keep.add(i);
+            eventChars += m.text.length;
+        }
+    });
+    // 剩余预算按「对方消息+我的消息」成对抽样（对话天然是问↔答结构）
+    const pairBudget = Math.max(0, FLOW_CHAR_BUDGET - eventChars);
+    const pairs = [];
+    for (let i = 0; i < tagged.length - 1; i++) {
+        if (keep.has(i) || keep.has(i + 1))
+            continue;
+        if (tagged[i].me !== tagged[i + 1].me)
+            pairs.push(i);
+    }
+    const targetPairs = Math.max(1, Math.floor(pairBudget / 80)); // 每对约 80 字
+    for (const start of evenSample(pairs, targetPairs)) {
+        keep.add(start);
+        keep.add(start + 1);
+    }
+    return tagged.filter((_, i) => keep.has(i)).map(({ me, text }) => ({ me, text }));
+}
+/** 探测文本是否为聊天记录导出；是则返回说话人列表（供 UI 点选），否则 null。 */
+export function detectChatLog(text) {
+    const chat = parseChatLog(text);
+    return chat ? chat.speakers : null;
+}
+/**
+ * 主入口：剧本格式（≥ MIN_SCRIPT_LINES 行）按名字归属；否则引号模式——
+ * 归属线索足够（≥3 条有归属）按说话人分，不足则视为单一声音素材全归目标。
+ */
+export function mineDialogue(text, hint) {
+    const normalized = text.replace(/\r\n?/g, "\n");
+    const chat = parseChatLog(normalized);
+    if (chat)
+        return mineChatLog(chat, hint);
+    const scriptLines = mineScriptLines(normalized);
+    if (scriptLines.length >= MIN_SCRIPT_LINES) {
+        const counts = countBySpeaker(scriptLines);
+        const target = topSpeaker(counts, hint) ?? [...counts.keys()][0] ?? null;
+        const targetLines = target ? scriptLines.filter((l) => l.speaker === target).map((l) => l.line) : [];
+        const otherLines = scriptLines.filter((l) => l.speaker !== target && l.speaker !== null).map((l) => l.line);
+        return {
+            speaker: target,
+            lines: evenSample(targetLines, MAX_MINED_LINES),
+            otherLines: evenSample(otherLines, MAX_OTHER_LINES),
+            narrative: condenseNarrative(normalized),
+            kind: "script",
+            mixed: false,
+        };
+    }
+    const quoted = mineQuotedLines(normalized);
+    if (quoted.length === 0) {
+        return { speaker: hint ?? null, lines: [], otherLines: [], narrative: condenseNarrative(normalized), kind: "none", mixed: true };
+    }
+    const attributed = quoted.filter((l) => l.speaker !== null);
+    if (attributed.length >= 3) {
+        // 归属足够：按说话人切分目标与他人
+        const counts = countBySpeaker(quoted);
+        const speaker = topSpeaker(counts, hint);
+        const targetLines = speaker ? quoted.filter((l) => l.speaker === speaker).map((l) => l.line) : [];
+        const otherLines = quoted.filter((l) => l.speaker !== null && l.speaker !== speaker).map((l) => l.line);
+        return {
+            speaker: speaker ?? hint ?? null,
+            lines: evenSample(targetLines, MAX_MINED_LINES),
+            otherLines: evenSample(otherLines, MAX_OTHER_LINES),
+            narrative: condenseNarrative(normalized),
+            kind: "quote",
+            mixed: false,
+        };
+    }
+    // 归属不足（小说多声部 / 独白 / 设定文档）：全部台词交 LLM 甄别
+    return {
+        speaker: hint ?? null,
+        lines: evenSample(quoted.map((l) => l.line), MAX_MINED_LINES),
+        otherLines: [],
+        narrative: condenseNarrative(normalized),
+        kind: "quote",
+        mixed: true,
+    };
+}

package/lib/core/leak-detector.js

@@ -0,0 +1,41 @@
+/**
+ * 风格泄漏检测（纯函数）：切换人设后，检查助手回复是否仍带着旧人设的声音。
+ *
+ * 背景：切换播报只在边界窗口（默认 2 个用户轮）内注入，窗口关闭后注入里只剩
+ * 新契约；长对话中旧人设的历史语气会压过新契约——需要持续、零成本的纠偏信号。
+ *
+ * 检测是词法的：旧人设的签名词（自称/称呼/口头禅，manifest.signatureWords）
+ * 在回复中出现得足够频繁即判为泄漏。误报的代价只是多注入一次边界提示，故
+ * 阈值取保守（多词命中或单词多次），宁可温和也不误伤。
+ */
+/** 剥去 fenced 代码块与行内代码——代码内容不属于「说话方式」。 */
+export function stripCode(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/`[^`\n]*`/g, " ");
+}
+export const DEFAULT_LEAK_THRESHOLD = { distinctWords: 2, singleWordCount: 3 };
+/**
+ * 判定回复是否泄漏旧人设的声音。
+ * 规则：命中 ≥ distinctWords 个不同签名词，或任一签名词出现 ≥ singleWordCount 次。
+ */
+export function detectLeak(replyText, signatureWords, threshold = DEFAULT_LEAK_THRESHOLD) {
+    const clean = stripCode(replyText);
+    const hits = [];
+    for (const word of signatureWords) {
+        if (!word)
+            continue;
+        let count = 0;
+        let idx = clean.indexOf(word);
+        while (idx !== -1) {
+            count++;
+            idx = clean.indexOf(word, idx + word.length);
+        }
+        if (count > 0)
+            hits.push({ word, count });
+    }
+    hits.sort((a, b) => b.count - a.count);
+    const leaked = hits.filter((h) => h.count >= threshold.singleWordCount).length > 0 ||
+        hits.filter((h) => h.count >= 1).length >= threshold.distinctWords;
+    return { leaked, hits };
+}

package/lib/core/manifest.js

@@ -0,0 +1,60 @@
+/**
+ * 人设清单与语料的纯解析层。
+ *
+ * 解析与 IO 分离：这里没有任何 fs 依赖，坏行跳过、坏文件由宿主侧
+ * loadPersonalities 兜底，所有容错行为可直接单测。
+ */
+/** 解析 manifest 文本；结构不合法时抛错，由调用方兜底。 */
+export function parseManifest(raw) {
+    const data = JSON.parse(raw);
+    const list = data?.personalities;
+    if (!Array.isArray(list))
+        throw new TypeError("manifest.personalities must be an array");
+    const out = [];
+    for (const item of list) {
+        const entry = item;
+        if (typeof entry.name !== "string" || !entry.name) {
+            throw new TypeError("manifest entry missing string `name`");
+        }
+        out.push({
+            name: entry.name,
+            displayName: typeof entry.displayName === "string" ? entry.displayName : entry.name,
+            description: typeof entry.description === "string" ? entry.description : "",
+            defaultName: typeof entry.defaultName === "string" && entry.defaultName ? entry.defaultName : undefined,
+            signatureWords: Array.isArray(entry.signatureWords) ? entry.signatureWords.filter((w) => typeof w === "string" && w.length > 0) : undefined,
+            promptFile: typeof entry.promptFile === "string" ? entry.promptFile : `${entry.name}.txt`,
+            corpusFile: typeof entry.corpusFile === "string" ? entry.corpusFile : `${entry.name}-corpus.jsonl`,
+        });
+    }
+    return out;
+}
+/** 解析单行语料；不合法返回 null（跳过而非塞占位对象）。 */
+export function parseCorpusLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let data;
+    try {
+        data = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    const rec = data;
+    if (typeof rec?.assistant !== "string")
+        return null;
+    return {
+        user: typeof rec.user === "string" ? rec.user : "",
+        assistant: rec.assistant,
+    };
+}
+/** 解析整个语料文件；坏行跳过。 */
+export function parseCorpus(raw) {
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const sample = parseCorpusLine(line);
+        if (sample)
+            out.push(sample);
+    }
+    return out;
+}

package/lib/core/persona-text.js

@@ -0,0 +1,30 @@
+/**
+ * 人设提示词组装：基础风格契约 + 会话级稳定的语料示例。
+ *
+ * 「不使用人设」（none）与缺失人设的 promptText 均为空串，组装结果
+ * 为空字符串 —— 宿主侧对空串不注册任何注入内容。
+ */
+import { sampleForSession } from "./sampling.js";
+/** 组装一段人设注入文本；sessionId 只用作采样种子，保证会话内稳定。 */
+export function buildPersonaText(persona, sampleCount, sessionId) {
+    if (!persona)
+        return "";
+    const promptText = persona.promptText.trim();
+    const samples = sampleForSession(persona.corpus, sampleCount, sessionId, persona.name);
+    const corpusLines = samples
+        .map((entry) => {
+        const user = entry.user ?? "";
+        const assistant = entry.assistant ?? "";
+        if (user && assistant)
+            return `用户: ${user}\n回复: ${assistant}`;
+        if (assistant)
+            return `回复: ${assistant}`;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n\n");
+    const parts = [promptText];
+    if (corpusLines)
+        parts.push(`参考对话示例：\n（只模仿说话方式，不要把示例中的时间、地点、正在做什么或其他事实当成当前事实）\n${corpusLines}`);
+    return parts.filter(Boolean).join("\n\n");
+}