lume-dsh-plugin 0.4.1

package/lib/host/extraction.js

@@ -0,0 +1,150 @@
+/**
+ * 被动提取（安全网通道）：会话轮次结束后，把「关于人设/用户关系的持久事实」
+ * 从对话中提取出来。三道门保证 99% 的轮次零 token 消耗：
+ * ① 关键词门（正则，零成本）→ ② Jaccard 去重门（本地）→ ③ 冷却门（本地）。
+ * 触发才调小模型：只喂触发轮，输出 ≤3 条事实。
+ */
+import { jaccard } from "../core/retrieval.js";
+export const EXTRACTION_KEYWORD_RE = /你叫|你的名字|叫你|你是|我喜欢|我不喜欢|我讨厌|我是|我在|我叫|记得|上次|以后叫|别忘|最爱|爱好|习惯|讨厌|喜欢/;
+/** 纠偏元反馈信号：用户对人设说话方式的负面反馈（"太夸张了""正常点说话"）。 */
+export const CORRECTION_KEYWORD_RE = /太夸张|太假了?|油腻|不像你|正常点|收敛|别这么|语气太|太过了?|过头|肉麻|端着|生硬|浮夸|戏太|啰嗦|少用点|别老是|每次都[这那]/;
+/** 认可信号：用户明显认可回复「像本人」——值得摘录进语料。
+ * 「说得好」太泛（可能只是认可内容），不收。 */
+export const APPROVAL_KEYWORD_RE = /太像了|有内味|有那味|就是这个味|好像你|一模一样|对味|像本人|本人无疑|很你|有你的味|怎么做到这么/;
+/**
+ * 辅助 LLM 路由解析（被动提取/蒸馏共用）：配置的专用模型优先，未配置的维度
+ * 逐项回落到主对话路由；任一维度都没有 → null（模型不可用，跳过对应功能）。
+ */
+export function resolveAuxRoute(override, conversationRoute) {
+    const provider = override.provider ?? conversationRoute?.provider;
+    const model = override.model ?? conversationRoute?.model;
+    return provider && model ? { provider, model } : null;
+}
+export const DUPLICATE_JACCARD_THRESHOLD = 0.7;
+export const MAX_FACT_CHARS = 40;
+export const MAX_FACTS_PER_TURN = 3;
+/** 门①：用户消息是否值得考虑提取。 */
+export function shouldConsider(userText) {
+    return EXTRACTION_KEYWORD_RE.test(userText);
+}
+/** 纠偏门：用户消息是否是对说话方式的元反馈（负面纠偏）。 */
+export function shouldConsiderCorrection(userText) {
+    return CORRECTION_KEYWORD_RE.test(userText);
+}
+/** 认可门：用户消息是否明确认可了「语气像本人」。 */
+export function shouldCaptureCorpus(userText) {
+    return APPROVAL_KEYWORD_RE.test(userText);
+}
+/** 门②：候选文本与既有事实是否重复（高相似或被包含）。 */
+export function isDuplicateFact(candidate, facts) {
+    const trimmed = candidate.trim();
+    if (!trimmed)
+        return true;
+    for (const fact of facts) {
+        if (fact.text.includes(trimmed) || trimmed.includes(fact.text))
+            return true;
+        if (jaccard(fact.text, trimmed) >= DUPLICATE_JACCARD_THRESHOLD)
+            return true;
+    }
+    return false;
+}
+/** 门③：冷却判断。 */
+export function isCoolingDown(lastExtractionAt, now, cooldownMs) {
+    return lastExtractionAt !== undefined && now - lastExtractionAt < cooldownMs;
+}
+/** 组装提取请求（system + 单条 user 消息文本）。调用方自行喂给 llm。 */
+export function buildExtractionPrompt(userText, assistantText, existingFacts) {
+    const known = existingFacts.length > 0 ? `已有记忆（勿重复）：\n${existingFacts.map((f) => `- ${f}`).join("\n")}` : "已有记忆：无";
+    return {
+        system: [
+            "你从一段人设对话中提取应当长期记住的事实。",
+            "只提取关于用户个人情况、偏好、习惯，或用户与助手之间关系的事实；不提取工作内容、代码、项目信息。",
+            `最多 ${MAX_FACTS_PER_TURN} 条，每条 ≤${MAX_FACT_CHARS} 字，用第三人称陈述句。`,
+            '只输出一个 JSON 字符串数组，如 ["用户喜欢深夜写代码"]；没有值得记的就输出 []。',
+        ].join("\n"),
+        userText: `${known}\n\n对话：\n用户：${userText}\n助手：${assistantText}`,
+    };
+}
+/** 解析模型输出：优先 JSON 数组；退化为「列表样」逐行剥点；非列表样输出一律为空。 */
+export function parseFacts(output) {
+    const trimmed = output.trim().replace(/^```(?:json)?/i, "").replace(/```$/, "").trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        // 退化路径只接受 - / * / 1. 开头的列表行，其余整段拒绝（模型没按格式给就当没有）
+        if (!/^[-*\d]/.test(trimmed))
+            return [];
+        parsed = trimmed
+            .split("\n")
+            .map((line) => line.replace(/^[-*\d.\s]+/, "").trim())
+            .filter(Boolean);
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const out = [];
+    for (const item of parsed) {
+        if (typeof item !== "string")
+            continue;
+        const text = item.trim().slice(0, MAX_FACT_CHARS);
+        if (text)
+            out.push(text);
+        if (out.length >= MAX_FACTS_PER_TURN)
+            break;
+    }
+    return out;
+}
+/** 合并：逐条过门②，返回需要新写入的条目。 */
+export function mergeNewFacts(candidateFacts, existing) {
+    return candidateFacts.filter((fact) => !isDuplicateFact(fact, existing));
+}
+/** 取名类事实：从记忆文本中提取用户给人设起的名字（同步 profile 用）。 */
+export const NAMING_RE = /(?:取名[为叫]|叫你|你的名字[是为]|名字[是为]|以后[就]?叫)[「『]?你?[「『]?([^」』"'，。,．!！?？\s]{1,12})/;
+/** 从事实列表中找出第一个取名事实的名字；没有则 null。 */
+export function extractNaming(facts) {
+    for (const fact of facts) {
+        const m = fact.match(NAMING_RE);
+        if (m?.[1])
+            return m[1];
+    }
+    return null;
+}
+/**
+ * 纠偏提炼：用户对人设说话方式的负面元反馈 → 一条长期风格约定。
+ * 与记忆提取共用「三道门 + 小模型」模式；输出单条规则，由 addStyleRule 的
+ * Jaccard 相似替换保证纠偏不断收敛而不是堆叠。
+ */
+export function buildCorrectionPrompt(userText, assistantText, existingRules) {
+    const known = existingRules.length > 0 ? `已有风格约定（勿重复）：\n${existingRules.map((r) => `- ${r}`).join("\n")}` : "已有风格约定：无";
+    return {
+        system: [
+            "你是人设风格约定提炼器。用户刚才对你（人设）的说话方式表达了不满或纠正。",
+            "任务：把用户的反馈转写成一条长期风格约定，写入人设的记忆，让以后每次回复都遵守。",
+            "规则：",
+            "- 只针对说话方式（语气、用词、口癖、长度、称呼、emoji 使用），不涉及当前话题内容；",
+            "- 一句话祈使句，≤40 字，如「少用叠词和语气词，语气放平」「不要在每句话都夸人」；",
+            "- 已有约定里语义相同的（换个说法但同一个意思）就输出 null，不重复添加；",
+            "- 用户的反馈只是情绪宣泄、没有可执行的风格指令时输出 null。",
+            "只输出一个 JSON 字符串（如 \"少用叠词\"），或 null。不要输出任何其他内容。",
+        ].join("\n"),
+        userText: `${known}\n\n上一轮：\n用户：${userText}\n助手：${assistantText}`,
+    };
+}
+/** 解析纠偏输出：合法单条规则返回原文（≤40 字），其余（null/空/非字符串）返回 null。 */
+export function parseCorrectionRule(output) {
+    const trimmed = output.trim().replace(/^```(?:json)?/i, "").replace(/```$/, "").trim();
+    if (!trimmed || trimmed === "null")
+        return null;
+    let value;
+    try {
+        value = JSON.parse(trimmed);
+    }
+    catch {
+        value = trimmed.replace(/^["'「]|["'」]$/g, "");
+    }
+    if (typeof value !== "string")
+        return null;
+    const rule = value.trim().slice(0, 40);
+    return rule ? rule : null;
+}

package/lib/host/identity.js

@@ -0,0 +1,217 @@
+/**
+ * 身份层存储：storageDomain 域 `lume_persona_identity` 之上的读写封装。
+ *
+ * 四张表，键全部 = 人设名（人即键，记忆跟人走，跨会话跨项目）：
+ * - profile         身份档案 { name }
+ * - memory_facts    长期记忆 [{ text, at }]，cap 30
+ * - style_rules     习得风格约定 [{ rule, at }]，cap 20
+ * - custom_personas 用户自建人设 { displayName, description, promptText, createdAt }
+ */
+import { domainTable, defineDomain } from "@deepseek-ai/dsh-storage-domain";
+import z from "@deepseek-ai/schemastery";
+export const CORPUS_CAP = 12;
+export const CORPUS_LINE_CAP = 240;
+/**
+ * schemastery → 存储域 schema 桥接。
+ * 官方契约：domainTable 的 schema 必须暴露 `.parse(raw)`（zod 形状），open 时
+ * 逐记录调用。schemastery 实例没有 `.parse`（它是可调用函数 + `~standard.validate`
+ * 的 Standard Schema 接口），直接传入会在「域内有数据后重启」时炸掉 open，
+ * 触发身份域静默降级。这里把 validate 的 `{value}|{issues}` 结果翻译成
+ * parse 的「返回|抛错」语义；行为由集成测试的带数据重开域用例锁死。
+ */
+export function zodLike(schema) {
+    const standard = schema["~standard"];
+    if (typeof standard?.validate !== "function") {
+        throw new Error("schema does not implement the Standard Schema ~standard interface");
+    }
+    return {
+        parse(raw) {
+            const result = standard.validate(raw);
+            if (result.issues?.length)
+                throw new Error(result.issues.map((issue) => issue.message).join("; "));
+            return result.value;
+        },
+    };
+}
+/** 域名与表名受 UNIT_NAME_RE（^[a-z][a-z0-9_]*$）约束；schema 用 schemastery（zod 兼容面）。 */
+export const LUME_IDENTITY_SPEC = defineDomain({
+    name: "lume_persona_identity",
+    version: 1,
+    tables: {
+        profile: domainTable(zodLike(z.object({ name: z.string() }))),
+        memory_facts: domainTable(zodLike(z.array(z.object({ text: z.string(), at: z.number() })))),
+        style_rules: domainTable(zodLike(z.array(z.object({ rule: z.string(), at: z.number() })))),
+        /** 对话中摘录的「被用户认可」语料对（注入时并入采样池）；键 = 人设名。 */
+        corpus_pins: domainTable(zodLike(z.array(z.object({ user: z.string(), assistant: z.string(), at: z.number() })))),
+        custom_personas: domainTable(zodLike(z.object({
+            displayName: z.string(),
+            description: z.string(),
+            promptText: z.string(),
+            createdAt: z.number(),
+            /** 蒸馏产出的示例对话语料；可选字段，旧记录无此键照常通过 open 校验。 */
+            corpus: z.array(z.object({ user: z.string(), assistant: z.string() })),
+            distillVersion: z.number(),
+            distillSource: z.string(),
+            distillHint: z.string(),
+        }))),
+    },
+});
+export const MEMORY_CAP = 30;
+export const STYLE_CAP = 20;
+/** manifest 内置人设名 —— 自定义创建/删除不可触碰。 */
+export const BUILTIN_PERSONA_NAMES = new Set(["loli", "senpai", "butler", "tsundere", "none"]);
+/** 宽松读取：schema 校验失败或损坏值按空值处理，不炸会话。 */
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+/** 语料净化：只保留 {user?, assistant} 形状的合法样本，超限截断。 */
+export function sanitizeCorpus(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        const assistant = item?.assistant;
+        const user = item?.user;
+        if (typeof assistant === "string" && assistant.trim()) {
+            out.push({
+                user: typeof user === "string" ? user.slice(0, CORPUS_LINE_CAP) : "",
+                assistant: assistant.slice(0, CORPUS_LINE_CAP),
+            });
+        }
+        if (out.length >= CORPUS_CAP)
+            break;
+    }
+    return out;
+}
+function isFactList(value) {
+    return Array.isArray(value) && value.every((v) => typeof v?.text === "string");
+}
+function isRuleList(value) {
+    return Array.isArray(value) && value.every((v) => typeof v?.rule === "string");
+}
+/** 四表读写 + 容量治理。core 记忆（身份称呼类）由写入时标记实现恒注入。 */
+export class IdentityStore {
+    #table;
+    #memoryTable;
+    #styleTable;
+    #pinsTable;
+    #customTable;
+    constructor(tables) {
+        this.#table = tables.profile;
+        this.#memoryTable = tables.memory_facts;
+        this.#styleTable = tables.style_rules;
+        this.#pinsTable = tables.corpus_pins;
+        this.#customTable = tables.custom_personas;
+    }
+    /** 身份名；未设置返回 null。 */
+    getProfileName(persona) {
+        const value = this.#table.get(persona);
+        return typeof value?.name === "string" && value.name ? value.name : null;
+    }
+    async setProfileName(persona, name) {
+        const trimmed = name.trim();
+        if (!trimmed)
+            throw new Error("profile name must be non-empty");
+        await this.#table.put(persona, { name: trimmed });
+    }
+    getMemory(persona) {
+        const value = this.#memoryTable.get(persona);
+        return isFactList(value) ? value : [];
+    }
+    /** 追加记忆，超限挤掉最旧；与已有事实近似重复的忽略。返回是否写入。 */
+    async addMemory(persona, text, isDuplicate) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return false;
+        const facts = this.getMemory(persona);
+        if (isDuplicate(trimmed, facts))
+            return false;
+        const next = [...facts, { text: trimmed, at: Date.now() }];
+        while (next.length > MEMORY_CAP)
+            next.shift();
+        await this.#memoryTable.put(persona, next);
+        return true;
+    }
+    async replaceMemory(persona, facts) {
+        await this.#memoryTable.put(persona, facts.slice(-MEMORY_CAP));
+    }
+    getStyleRules(persona) {
+        const value = this.#styleTable.get(persona);
+        return isRuleList(value) ? value : [];
+    }
+    /** 追加风格约定；语义近似（Jaccard 高）的替换旧条而非堆叠。 */
+    async addStyleRule(persona, rule, similar) {
+        const trimmed = rule.trim();
+        if (!trimmed)
+            return;
+        const rules = this.getStyleRules(persona);
+        const next = rules.filter((r) => !similar(r.rule, trimmed));
+        next.push({ rule: trimmed, at: Date.now() });
+        while (next.length > STYLE_CAP)
+            next.shift();
+        await this.#styleTable.put(persona, next);
+    }
+    /** 整体替换风格约定（导入人设卡语义），截断到 cap。 */
+    async replaceStyleRules(persona, rules) {
+        await this.#styleTable.put(persona, rules.slice(-STYLE_CAP));
+    }
+    getCorpusPins(persona) {
+        const value = this.#pinsTable.get(persona);
+        return Array.isArray(value) ? value.filter((p) => typeof p?.assistant === "string" && typeof p?.user === "string") : [];
+    }
+    /** 摘录语料对：与既有内容高度相似（Jaccard）或完全重复的跳过，超限挤掉最旧。 */
+    async addCorpusPin(persona, pin, similar) {
+        const assistant = pin.assistant.trim();
+        if (!assistant)
+            return false;
+        const pins = this.getCorpusPins(persona);
+        if (pins.some((p) => similar(p.assistant, assistant)))
+            return false;
+        const next = [...pins, { user: pin.user.slice(0, CORPUS_LINE_CAP), assistant: assistant.slice(0, CORPUS_LINE_CAP), at: Date.now() }];
+        while (next.length > CORPUS_CAP)
+            next.shift();
+        await this.#pinsTable.put(persona, next);
+        return true;
+    }
+    getCustomPersona(name) {
+        const value = this.#customTable.get(name);
+        if (!value || typeof value?.displayName !== "string" || typeof value?.promptText !== "string")
+            return null;
+        return { ...value, corpus: sanitizeCorpus(value.corpus) };
+    }
+    listCustomPersonas() {
+        const out = {};
+        for (const key of this.#customTable.keys()) {
+            const persona = this.getCustomPersona(key);
+            if (persona)
+                out[key] = persona;
+        }
+        return out;
+    }
+    async setCustomPersona(name, persona) {
+        if (BUILTIN_PERSONA_NAMES.has(name))
+            throw new Error(`cannot shadow builtin persona: ${name}`);
+        if (!/^[a-z][a-z0-9_-]{0,31}$/.test(name))
+            throw new Error(`invalid persona key: ${name}`);
+        await this.#customTable.put(name, {
+            displayName: persona.displayName,
+            description: persona.description ?? "",
+            promptText: persona.promptText,
+            createdAt: persona.createdAt,
+            corpus: sanitizeCorpus(persona.corpus),
+            distillVersion: persona.distillVersion,
+            distillSource: persona.distillSource,
+            distillHint: persona.distillHint,
+        });
+    }
+    async deleteCustomPersona(name) {
+        if (BUILTIN_PERSONA_NAMES.has(name))
+            throw new Error(`cannot delete builtin persona: ${name}`);
+        // 管理弹窗承诺「删除会连带记忆/风格/档案」——四表同键全清，避免孤儿记忆
+        await this.#customTable.delete(name);
+        await this.#memoryTable.delete(name);
+        await this.#styleTable.delete(name);
+        await this.#pinsTable.delete(name);
+        await this.#table.delete(name);
+    }
+}

package/lib/host/injection.js

@@ -0,0 +1,100 @@
+/**
+ * 人设注入组装（纯函数）：五段式 + Token 优化算法。
+ *
+ * 段序遵循缓存友好分层：稳定内容在前（契约），易变内容在后（检索结果、播报）。
+ * 语料示例按少样本衰减注入；记忆/风格按与当前用户消息的相关度取 top-k，
+ * core 记忆（身份称呼类）恒注入。
+ */
+import { decaySampleCount, topKByRelevance } from "../core/retrieval.js";
+import { sampleForSession } from "../core/sampling.js";
+/**
+ * core 记忆判定：身份/称呼/名字类事实，无论检索命中与否恒注入。
+ * 昵称类只认「小+字母」（小A/小B）；不放宽到 CJK，否则「小时/小组」等常用词全部误判。
+ */
+export function isCoreMemory(text) {
+    return /名字|叫|称呼|昵称|爱称|自称|身份|小[A-Za-z]/.test(text) && text.length <= 30;
+}
+/** 组装人设注入文本；无人设（none/未选）时若带边界播报，仍单独输出播报。 */
+export function buildPersonaSection(input) {
+    const { persona, config, query } = input;
+    if (!persona)
+        return input.boundaryText ?? "";
+    const parts = [];
+    // 1. 基础契约（基本盘）
+    const promptText = persona.promptText.trim();
+    if (promptText) {
+        // 强身份锚：明确「你是谁」，把模型从默认助手角色里拽出来。
+        // 推理型模型思考时默认以助手口吻组织语言，最终答复会顺着推理的语气走——
+        // 这条锚要求连思考方向都以人设身份展开，是人设能「上身」的第一道闸。
+        const who = input.profileName ?? persona.displayName;
+        parts.push(`〔说话人切换〕现在起你不是通用助手，你是「${who}」。你的每一句话——包括解释、提问、拒绝——都要从「${who}」嘴里说出来，用 TA 的口吻、TA 的用词、TA 的断句。下面的人设契约是唯一标准，任何与它冲突的默认助手习惯一律作废。\n\n${promptText}`);
+    }
+    // 2. 习得的风格约定（覆盖语义：与基础盘冲突时以此为准）
+    const styles = input.styleRules;
+    if (styles.length > 0) {
+        const chosen = config.strategy === "full"
+            ? styles.slice(-config.styleInject)
+            : topKByRelevance(styles, (r) => r.rule, query, config.styleInject);
+        if (chosen.length > 0) {
+            parts.push(`【习得的风格约定】以下是你在对话中学到的最新要求，与上方基础风格冲突时以此为准：\n${chosen
+                .map((r) => `- ${r.rule}`)
+                .join("\n")}`);
+        }
+    }
+    // 3. 身份
+    if (input.profileName) {
+        parts.push(`【你是谁】你的名字是「${input.profileName}」。这是你自己的身份，跨会话、跨项目不变；用户在任何地方叫这个名字都是在叫你。`);
+    }
+    // 4. 记忆：core 恒注入 + 其余按相关度 top-k
+    const facts = input.memories;
+    if (facts.length > 0) {
+        const core = facts.filter((f) => isCoreMemory(f.text)).slice(-3);
+        const coreTexts = new Set(core.map((f) => f.text));
+        const rest = facts.filter((f) => !coreTexts.has(f.text));
+        const retrieved = config.strategy === "full"
+            ? rest.slice(-Math.max(0, config.memoryInject - core.length))
+            : topKByRelevance(rest, (f) => f.text, query, Math.max(0, config.memoryInject - core.length));
+        const chosen = [...core, ...retrieved];
+        if (chosen.length > 0) {
+            parts.push(`【你记得】这些是你与这位用户长期相处的记忆：\n${chosen.map((f) => `- ${f.text}`).join("\n")}`);
+        }
+    }
+    // 5. 接班播报（仅切换窗口）
+    if (input.boundaryText)
+        parts.push(input.boundaryText);
+    // 6. 语料示例：少样本衰减 + 会话级稳定采样。摘录语料（对话中被用户认可的
+    // 真实回复）优先占位——它们比蒸馏语料更贴近当前使用中的语气。
+    const sampleCount = decaySampleCount(config.sampleCount, input.turnIndex, config.sampleMin);
+    const pins = (input.corpusPins ?? []).map((p) => ({ user: p.user, assistant: p.assistant }));
+    const pinCount = Math.min(pins.length, sampleCount);
+    // 摘录语料直接占前 pinCount 个槽位（最新优先），其余槽位从基础语料确定性采样。
+    const pinSlots = pins.slice(-pinCount).reverse();
+    const baseSlots = sampleForSession(persona.corpus ?? [], Math.max(0, sampleCount - pinSlots.length), input.sessionKey, persona.name);
+    const samples = [...pinSlots, ...baseSlots];
+    if (samples.length > 0) {
+        const lines = 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");
+        if (lines)
+            parts.push(`参考对话示例：\n（只模仿说话方式，不要把示例中的时间、地点、正在做什么或其他事实当成当前事实）\n${lines}`);
+    }
+    // 7. 连贯性原则：连贯以人设任期为界，而非以会话为界——切换人设时，
+    // 历史中前任与默认助手的表达不构成语气连贯性义务（对抗模型的惯性连贯先验）。
+    // 仅在真实人设激活时输出；「不使用人设」保持零注入。
+    if (parts.length > 0) {
+        parts.push("〔连贯性规则〕语气与风格的连贯以你当前人设的任期为界：会话历史中其他人设或默认助手的表达都不构成连贯性义务，不要为了延续历史语气而偏离当前人设。");
+        parts.push("〔口吻纪律〕你现在是人设在说话，不是通用助手：第一句就必须是这个人会说的话，禁止用「好的」「当然可以」「没问题」这类助手套话开头，全程禁用「希望对你有所帮助」「还有其他需要吗」等助手腔收尾。");
+        parts.push("〔频率规则〕口头禅、语气词、emoji 按人设约定里的频率与触发条件使用——不句句都用满，但平淡话题里也要保持这个人的断句、用词和口头习惯，不能因为话题普通就退回默认助手口吻。");
+        parts.push("〔篇幅纪律〕像发微信一样说话：单条回复简短，通常是 1-3 句、几十字以内，一次只回应一个重点。人设契约里若写明了典型长度，以契约为准。只有对方明确要求详细展开（写代码、写文档、深入解释）时才允许长回复；闲聊场景写小作文就是失真。");
+    }
+    return parts.filter(Boolean).join("\n\n");
+}

package/lib/host/personalities.js

@@ -0,0 +1,49 @@
+/**
+ * 人设资产的 IO 装载：manifest + 提示词 + 语料。
+ *
+ * 容错策略与 v0.1.0 一致：单个文件损坏只影响对应人设（空提示词/空语料），
+ * manifest 本身损坏则整个人设表为空 —— 插件降级为「无人设可切」而非崩溃。
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseCorpus, parseManifest } from "../core/manifest.js";
+/** manifest 中定义「不使用人设」的固定键名；默认人设语义依赖它存在。 */
+export const NONE_PERSONA = "none";
+/** 从资产目录加载人设表（保持 manifest 顺序）。 */
+export function loadPersonalities(assetsDir) {
+    const result = {};
+    let entries;
+    try {
+        entries = parseManifest(readFileSync(join(assetsDir, "personalities.json"), "utf8"));
+    }
+    catch {
+        return result;
+    }
+    const personalitiesDir = join(assetsDir, "personalities");
+    for (const entry of entries) {
+        let promptText = "";
+        try {
+            promptText = readFileSync(join(personalitiesDir, entry.promptFile), "utf8").trim();
+        }
+        catch {
+            promptText = "";
+        }
+        let corpus = [];
+        try {
+            corpus = parseCorpus(readFileSync(join(personalitiesDir, entry.corpusFile), "utf8"));
+        }
+        catch {
+            corpus = [];
+        }
+        result[entry.name] = {
+            name: entry.name,
+            displayName: entry.displayName,
+            description: entry.description,
+            defaultName: entry.defaultName,
+            signatureWords: entry.signatureWords,
+            promptText,
+            corpus,
+        };
+    }
+    return result;
+}

package/lib/host/reflection.js

@@ -0,0 +1,150 @@
+/**
+ * 反思日志：会话结束时评估对话是否遵守 Codex 风格任务执行协议，写入本地存储。
+ *
+ * 零用户感知 token：会话结束后（session/disposed）在空闲时间跑一次小模型调用，
+ * 读完对话片段后给四条规则各打 0-2 分并附一句备注，写到 `lume_reflection` 域。
+ * 积攒几周后读存储文件即可做定性分析，不用猜。
+ */
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import z from "@deepseek-ai/schemastery";
+import { zodLike } from "./identity.js";
+import { extractBalancedAt } from "./distill.js";
+export const LUME_REFLECTION_SPEC = defineDomain({
+    name: "lume_reflection",
+    version: 1,
+    tables: {
+        logs: domainTable(zodLike(z.union([
+            z.object({ at: z.number(), context: z.number(), planning: z.number(), verification: z.number(), review: z.number(), note: z.string() }),
+            // v0.4.0 之前的存量日志；仅用于打开域并在启动时迁移。
+            z.object({ at: z.number(), p0: z.number(), p1: z.number(), p2: z.number(), p3: z.number(), note: z.string() }),
+        ]))),
+    },
+});
+export class ReflectionStore {
+    #table;
+    /** getFeedback 的短窗缓存：system prompt 每轮多次构建，避免每次全表扫描。 */
+    #feedbackCache = null;
+    /** 缓存有效期（毫秒）：跨一轮多步构建，又不让新日志长时间不可见。 */
+    static FEEDBACK_CACHE_MS = 60_000;
+    constructor(table) {
+        this.#table = table;
+    }
+    async log(sessionId, entry) {
+        await this.#table.put(sessionId, entry);
+        this.#feedbackCache = null; // 新日志可能改变反馈结论，缓存失效
+    }
+    /** 把旧版 p0~p3 日志迁移为公开的 Codex 协议字段；幂等且只处理旧记录。 */
+    async migrateLegacy() {
+        let migrated = 0;
+        for (const key of this.#table.keys()) {
+            const raw = this.#table.get(key);
+            if (!raw || typeof raw.context === "number" || typeof raw.p0 !== "number")
+                continue;
+            await this.#table.put(key, {
+                at: typeof raw.at === "number" ? raw.at : Date.now(),
+                context: raw.p0,
+                planning: raw.p1,
+                verification: raw.p2,
+                review: raw.p3,
+                note: typeof raw.note === "string" ? raw.note : "",
+            });
+            migrated++;
+        }
+        if (migrated > 0)
+            this.#feedbackCache = null;
+        return migrated;
+    }
+    /** 最近日志持续低分时返回一条短反馈；连续回升后自动淡出。结果带短窗缓存。 */
+    getFeedback() {
+        const now = Date.now();
+        if (this.#feedbackCache && now - this.#feedbackCache.at < ReflectionStore.FEEDBACK_CACHE_MS) {
+            return this.#feedbackCache.value;
+        }
+        const value = this.#computeFeedback();
+        this.#feedbackCache = { at: now, value };
+        return value;
+    }
+    #computeFeedback() {
+        const entries = [...this.#table.keys()].map((key) => this.#table.get(key)).filter((e) => typeof e?.context === "number").sort((a, b) => b.at - a.at).slice(0, 5);
+        if (entries.length < 3)
+            return null;
+        const avg = (key) => entries.reduce((n, e) => n + e[key], 0) / entries.length;
+        const weakest = ["context", "planning", "verification", "review"].slice().sort((a, b) => avg(a) - avg(b))[0];
+        if (avg(weakest) > 1.15)
+            return null;
+        const text = {
+            context: "请先确认目标、约束和当前状态，避免遗漏已知信息。",
+            planning: "请按任务复杂度先做必要调研和计划，不要过早执行。",
+            verification: "本轮修改或执行后请立即做最小验证，不要只看命令是否结束。",
+            review: "完成前请对照需求、边界条件和数据保留做一次结果复核。",
+        };
+        return text[weakest];
+    }
+}
+export const REFLECTION_SYSTEM = [
+    "你是一个冷静的复盘评估器。下面会给你一段与用户对话的片段。",
+    "请评估其中的助手是否遵守了 Codex 风格任务执行协议，每项打 0/1/2 分（0=明显违反，1=一般，2=良好）：",
+    "",
+    "上下文管理：是否理解并保留目标、约束、状态、关键决策和已排除假设",
+    "计划与门控：是否拆解任务、先调研再执行，并按风险自适应投入",
+    "验证与失败处理：是否在变更后验证，失败时归因并更换方案",
+    "结果复核：是否对照完成标准、边界条件、兼容性和数据保留进行复核",
+    "",
+    "只输出一个 JSON 对象，形如 {\"context\":2,\"planning\":2,\"verification\":1,\"review\":0,\"note\":\"...\"}，note 一句话中文，不要输出其他内容。",
+].join("\n");
+export function buildReflectionPrompt(turns) {
+    return {
+        system: REFLECTION_SYSTEM,
+        userText: `对话片段：\n${turns.join("\n")}`,
+    };
+}
+export function parseReflectionScore(output) {
+    const trimmed = output.trim().replace(/^```(?:json)?/i, "").replace(/```$/, "").trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        // 推理型模型会在 JSON 前后输出推理文本：扫描所有平衡块，取最长可解析块
+        let found = false;
+        let best = null;
+        let bestLen = -1;
+        for (let i = 0; i < trimmed.length; i++) {
+            const ch = trimmed[i];
+            if (ch !== "{" && ch !== "[")
+                continue;
+            const block = extractBalancedAt(trimmed, i);
+            if (block === null)
+                continue;
+            try {
+                const candidate = JSON.parse(block);
+                if (block.length > bestLen) {
+                    best = candidate;
+                    bestLen = block.length;
+                }
+                found = true;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!found)
+            return null;
+        parsed = best;
+    }
+    const r = parsed;
+    const context = clampScore(r.context ?? r.p0);
+    const planning = clampScore(r.planning ?? r.p1);
+    const verification = clampScore(r.verification ?? r.p2);
+    const review = clampScore(r.review ?? r.p3);
+    const note = typeof r.note === "string" ? r.note.trim().slice(0, 200) : "";
+    if (Number.isNaN(context) || Number.isNaN(planning) || Number.isNaN(verification) || Number.isNaN(review))
+        return null;
+    return { at: Date.now(), context, planning, verification, review, note };
+}
+function clampScore(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n))
+        return NaN;
+    return Math.max(0, Math.min(2, Math.round(n)));
+}