dsh-daughter 0.6.3 → 0.6.5

package/README.md

@@ -4,6 +4,8 @@
 
 > 记忆跟着角色走，不跟着会话走：换对话框、换工作区，关系与经历都还在。
 
+> ⚠️ **用途边界**：本插件是给 **DSH 做人格演变**用的。它的记忆与情绪会**跨窗口贯通、并带时间感**（在 1 号窗口说一句，切到 2 号窗口她会接上一句）。**不要在正式/工作对话里开启**，否则私人聊天里的记忆会串进你的工作上下文，污染正常问答。
+
 ## 对接对象（先看这张表）
 
 | 项 | 具体是什么 |
@@ -41,6 +43,8 @@ npx dsh-daughter-token --write-to "<VPet 安装目录>\mod\DshDaughter\plugin"
 
 也可以手动把 `brain/brainstem/connector_token` 的内容复制成 `plugin/token.txt`，或设置环境变量 `DSH_DAUGHTER_TOKEN`。令牌缺失时 MOD 仍会启动，但请求会被 401 拒绝，日志里会写明原因。
 
+> 如果宿主把 `storage.data_root` 改到了别处，取令牌时要一起指定：`npx dsh-daughter-token --data-root <数据目录>`（或设 `DSH_DAUGHTER_DATA_ROOT`）。不指定的话，它会在插件目录里新建一个令牌，和插件实际用的那个对不上，连接器就会一直 401。
+
 **怎么编译**（MOD 源码在 `connectors/vpet/mod-src/`，目标框架 `net10.0-windows`）：
 
 ```powershell
@@ -118,6 +122,9 @@ https://fastly.jsdelivr.net/gh/han0han0le0ni/dsh-daughter@main/market/index.json
 
 之后在「发现」里搜 `daughter` 安装即可。索引里每个版本都钉死了 commit，装到的是可复现的版本。
 
+> jsDelivr 对 `@main` 有分支级缓存，刚发版时索引可能还停在旧版本。要立刻拿到最新索引，用固定 commit 的地址（每次发版后把 `<sha>` 换成当次发布提交）：
+> `https://fastly.jsdelivr.net/gh/han0han0le0ni/dsh-daughter@<sha>/market/index.json`
+
 > 社区目录（`dsh-plugin-catalog`，也就是「发现」里默认那份）收录的是 npm 上的包，本插件发布到 npm 之后会被抓取；在那之前，请用上面的自带索引源。
 
 **2. 直接从 git 装**

package/bin/connector-token.mjs

@@ -11,6 +11,8 @@
  *   npx dsh-daughter-token --rotate
  *
  * 参数：
+ *   --data-root <目录>  指定数据根目录（宿主把 storage.data_root 改到别处时必须传，
+ *                       否则会在这里新造一个令牌，和插件实际用的那个对不上）
  *   --write-to <目录>   同时写入 <目录>/token.txt（MOD / 壳直接读）
  *   --rotate            删掉旧令牌重新生成（所有连接器都要换新值）
  *   --json              机器可读
@@ -35,7 +37,11 @@ const value = (name, fallback) => {
 const pluginRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
 const config = loadConfig(pluginRoot, silentLogger);
-const dataRoot = resolveDataRoot(pluginRoot, config);
+
+// 宿主可能用 storage.data_root 覆盖 config.yaml 里的值；这里允许显式指定，
+// 避免在包目录里新造一个令牌，而插件实际读的是另一个位置
+const dataRootOverride = String(value('data-root', process.env.DSH_DAUGHTER_DATA_ROOT ?? '')).trim();
+const dataRoot = dataRootOverride ? resolve(pluginRoot, dataRootOverride) : resolveDataRoot(pluginRoot, config);
 const tokenPath = join(dataRoot, CONNECTOR_TOKEN_FILE);
 
 if (has('rotate')) {

package/config.yaml

@@ -3,7 +3,7 @@
 # 这里是一份"开箱即用"的保守默认值，不含任何个人偏好：
 #   - 所有数值都是代码内置默认值，改这里等价于改默认行为
 #   - 想调整请直接改本文件；升级插件会覆盖本文件，个人配置建议另存备份
-#   - 未实现的配置项（desktop / backend / shared_across_*）会在启动时告警并忽略
+#   - 未实现的配置项（backend）会在启动时告警并忽略；desktop 默认关闭，需显式打开
 version: 1
 character_id: daughter-default
 
@@ -42,6 +42,46 @@ association:
   # 换对话框后的第一句也靠它续接"上一个对话的结尾"。关掉即完全沉默。
   fallback_when_no_match: true
 
+# 窗口只是"工位"，不是记忆分区：换到另一个对话框，刚在别处说的话仍会被想起（§8.2）
+continuity:
+  enabled: true
+  # 别的窗口里多久以内的话算"刚刚"，会补进当前窗口（分钟）。隔太久就不再当"刚才"提
+  cross_window_minutes: 45
+  # 每轮最多补几条"别处刚说的话"，避免把整个对话历史都塞进来
+  cross_window_max: 2
+
+# "局"（进行中的活动）：同一件事跨窗口、跨轮会被切成一堆事件，这里归并成一个 thread，
+# 注入时给前情摘要而不是单条碎片（§8.2）。纯规则、不调模型：Dice 相似度 + 时间间隔。
+threading:
+  enabled: true
+  # 同一局两次发言的最大间隔（分钟），超过就算新的一局
+  gap_minutes: 45
+  # 标题 Dice 相似度门槛（0–1），达到才算同一局
+  similarity: 0.25
+  # 一局多久没动静就算结束（分钟）。超过这个时长就算"已结束（一直没动静）"，
+  # 不再当进行中的事往下推，但仍然留在寄存器里当落脚处
+  activity_ttl_minutes: 180
+  # 已结束的局再留多久才彻底出寄存器（分钟）。默认 24 小时：
+  # "昨晚那局"要还能看见，但别让旧账越攒越多
+  closed_retention_minutes: 1440
+  # 收尾话术：听到这些就算这一局结了（标"已结束"再留一会儿），不必等它自己凉。
+  # 判错只是少挂一局，不会丢记忆；想更宽松就往里加词
+  closing_phrases:
+    - 先这样
+    - 不玩了
+    - 不聊了
+    - 下次再说
+    - 回头再说
+    - 就到这儿
+    - 到此为止
+    - 收工
+    - 晚安
+    - 睡了
+  # 前情摘要最多带几轮
+  max_summary_turns: 4
+  # 每轮最多注入几个"进行中的局"
+  max_injected: 2
+
 skills:
   max_main: 1
   max_associated: 2
@@ -165,6 +205,10 @@ budget:
     persona: 300
     state_hint: 150
     event_digest: 1400
+    # 跨窗口块独立于当前话题检索：预算裁剪先动事件块，也动不到它
+    cross_window: 200
+    # 进行中的局：两个窗口共享同一局的前情摘要，优先级最高
+    thread: 200
     skill_digest: 500
     association: 300
     constraint: 120
@@ -182,7 +226,11 @@ safety:
 
 storage:
   scope: character          # 仅支持 character；其它取值会告警并按角色级运行
+  # 跨会话是否接力「此刻」的 L5（情绪/压力/疲劳/安全感）。事件库与人格始终是角色级。
+  #   true  = 换对话框后接着上一段，按闲置时长自然回落（默认，像人：换房间不清空情绪）
+  #   false = 每个会话从基线重新出生（旧行为，彻底隔离）
   shared_across_sessions: true
+  # false = L5 只在同一 workspace 内接力，换项目/目录不串味（工作窗口与私人窗口互不污染）
   shared_across_workspaces: true
   data_root: .              # 相对于插件根目录；运行时数据都写在这里
   backend: sqlite

package/dist/config.js

@@ -33,6 +33,32 @@ export const defaultConfig = {
         hop_decay: 0.6,
         fallback_when_no_match: true,
     },
+    continuity: {
+        enabled: true,
+        cross_window_minutes: 45,
+        cross_window_max: 2,
+    },
+    threading: {
+        enabled: true,
+        gap_minutes: 45,
+        similarity: 0.25,
+        activity_ttl_minutes: 180,
+        closed_retention_minutes: 1440,
+        closing_phrases: [
+            '先这样',
+            '不玩了',
+            '不聊了',
+            '下次再说',
+            '回头再说',
+            '就到这儿',
+            '到此为止',
+            '收工',
+            '晚安',
+            '睡了',
+        ],
+        max_summary_turns: 4,
+        max_injected: 2,
+    },
     skills: {
         max_main: 1,
         max_associated: 2,
@@ -113,6 +139,8 @@ export const defaultConfig = {
             persona: 300,
             state_hint: 150,
             event_digest: 1400,
+            cross_window: 200,
+            thread: 200,
             skill_digest: 500,
             association: 300,
             constraint: 120,
@@ -256,8 +284,12 @@ function warnUnsupported(config, logger) {
             scope: config.storage.scope,
         });
     }
-    if (!config.storage.shared_across_sessions || !config.storage.shared_across_workspaces) {
-        logger.warn('dsh-daughter: 跨会话/跨工作区共享固定开启，shared_across_* 目前不生效');
+    // shared_across_* 现在真的生效了：只作用于「此刻」的 L5 接力，事件库与人格仍是角色级
+    if (!config.storage.shared_across_sessions) {
+        logger.info('dsh-daughter: shared_across_sessions=false，每个会话从基线重新出生（L5 不接力）');
+    }
+    else if (!config.storage.shared_across_workspaces) {
+        logger.info('dsh-daughter: shared_across_workspaces=false，L5 只在同一工作区内接力');
     }
     if (!config.storage.single_writer) {
         logger.warn('dsh-daughter: single_writer=false，已关闭写锁，请确认没有并发写者');
@@ -291,6 +323,26 @@ function mergeDeep(base, override) {
     return result;
 }
 function normalizeConfig(config) {
+    // 隔离开关：只有明确写 false 才关，其它写法（缺省、字符串、undefined）都按默认开启
+    config.storage.shared_across_sessions = config.storage.shared_across_sessions !== false;
+    config.storage.shared_across_workspaces = config.storage.shared_across_workspaces !== false;
+    // 跨窗口时间感：分钟取整且至少 1，条数夹在 0–8
+    config.continuity.enabled = config.continuity.enabled !== false;
+    config.continuity.cross_window_minutes = Math.max(1, Math.round(num(config.continuity.cross_window_minutes, 45)));
+    config.continuity.cross_window_max = Math.max(0, Math.min(8, Math.round(num(config.continuity.cross_window_max, 2))));
+    // 局的归并：相似度夹在 0–1，时间窗口与条数取整
+    config.threading.enabled = config.threading.enabled !== false;
+    config.threading.similarity = clampUnit(config.threading.similarity, 0.25);
+    config.threading.gap_minutes = Math.max(1, Math.round(num(config.threading.gap_minutes, 45)));
+    config.threading.activity_ttl_minutes = Math.max(1, Math.round(num(config.threading.activity_ttl_minutes, 180)));
+    config.threading.closed_retention_minutes = Math.max(1, Math.round(num(config.threading.closed_retention_minutes, 1440)));
+    // 收尾话术：只留非空字符串；整组被写成空时退回默认，否则"结了没"永远判不出来
+    const closing = Array.isArray(config.threading.closing_phrases)
+        ? config.threading.closing_phrases.filter((phrase) => typeof phrase === 'string' && phrase.trim().length > 0)
+        : [];
+    config.threading.closing_phrases = closing.length > 0 ? closing : [...defaultConfig.threading.closing_phrases];
+    config.threading.max_summary_turns = Math.max(2, Math.min(12, Math.round(num(config.threading.max_summary_turns, 4))));
+    config.threading.max_injected = Math.max(0, Math.min(6, Math.round(num(config.threading.max_injected, 2))));
     config.retrieval.top_k = Math.max(1, Math.round(num(config.retrieval.top_k, 5)));
     config.retrieval.min_semantic = clampUnit(num(config.retrieval.min_semantic, 0.01), 0.01);
     // 回看感受的触发距离：0 会让每次召回都写一条，1 等于永不写，两端都无意义

package/dist/index.js

@@ -2,24 +2,25 @@ import { loadConfig, resolveDataRoot } from './config.js';
 import { performance } from 'node:perf_hooks';
 import { Store } from './store.js';
 import { Observability } from './runtime/observability.js';
-import { createRng, relativeTime, silentLogger, truncate } from './util.js';
+import { createRng, relativeTime, safeFileName, silentLogger, truncate } from './util.js';
 import { applyBodySignal, pickMotionByPad } from './runtime/body-link.js';
 import { decideIngest } from './runtime/filter.js';
-import { createInitialL5, selectSubpersona, updateL5 } from './runtime/state.js';
+import { carryL5, createInitialL5, selectSubpersona, updateL5 } from './runtime/state.js';
+import { assignThread, isDialogueSource, pruneOpenThreads } from './runtime/threading.js';
 import { evaluateSpeak, localDayKey } from './runtime/speak.js';
 import { readForeground } from './runtime/desktop-observe.js';
 import { containsDiagnosisLabel, evaluateSafety } from './runtime/safety.js';
 import { applySurprise, associateEvents, extractEvent, linkNewEvent, pickAssociationSeed, recallDrift, reconstructOnRecall, retrieveEvents, } from './runtime/memory.js';
-import { NO_MEMORY_CONSTRAINT, activateSkills, buildBlocks, buildEventDigest, buildPersonaText, buildRelationText, buildSkillDigest, buildStateHint, clipBlocks, matchReflex, WORKING_STYLE, } from './runtime/content.js';
+import { NO_MEMORY_CONSTRAINT, activateSkills, buildBlocks, buildCrossWindowDigest, buildEventDigest, buildPersonaText, buildThreadDigest, buildRelationText, buildSkillDigest, buildStateHint, clipBlocks, matchReflex, WORKING_STYLE, } from './runtime/content.js';
 import { applyPersonalitySignal } from './runtime/personality.js';
 import { applyPersonaDrift, buildPersonProfiles, buildStarMap, buildThingProfiles, bumpSkill, learnDraftSkill, maybeFreezeSkill, runTick, } from './runtime/maintenance.js';
 /** §6.1 时延预算：超时只告警与记日志，不做硬中断（SQLite 同步查询无法中途取消） */
 const RETRIEVE_BUDGET_MS = 150;
 const BEFORE_PROMPT_BUDGET_MS = 100;
-/** 换对话框后的第一句：接上"上一个对话的结尾"最多带几条、往前看多久 */
-const CONTINUATION_LIMIT = 2;
-const CONTINUATION_WINDOW_MS = 30 * 86_400_000;
-/** 已见过首轮的会话集合上限，超了整体清空（只影响"是否首轮"，丢一次判断无副作用） */
+/** 换对话框后的第一句：接上"上一段对话的结尾"最多带几条、往前看多久 */
+const CONTINUATION_LIMIT = 3;
+const CONTINUATION_WINDOW_MS = 7 * 86_400_000;
+/** 已见过首轮的会话集合上限（超出按最久未用淘汰，不再整体清空） */
 const SEEN_SESSIONS_CAP = 512;
 export function createDaughterPlugin(options) {
     return new Daughter(options);
@@ -39,6 +40,8 @@ class Daughter {
     handledTurns = new Map();
     /** 已经构建过 prompt 的会话：只有第一次才允许"续接上一个对话" */
     seenSessions = new Set();
+    /** 每个窗口已经贴过的"别处刚说的话"，跨窗口轨道靠它去重，避免同一件事反复提醒 */
+    injectedCross = new Map();
     rng;
     onMotion;
     /** 连接器令牌：主动开口探测桌面桥时带上（§12.2） */
@@ -67,8 +70,7 @@ class Daughter {
         const overdraftDelta = l5.stress > 0.7 ? 0.03 : -0.01;
         l5.emotionalOverdraft = Math.min(1, Math.max(0, l5.emotionalOverdraft + overdraftDelta));
         store.saveOverdraft(l5.emotionalOverdraft);
-        store.saveL5(l5);
-        this.sessions.set(sessionKey(ctx), l5);
+        this.commitL5(store, ctx, l5);
         this.logger.debug('on_user_message', {
             sessionId: ctx.sessionId,
             level: verdict.level,
@@ -118,17 +120,54 @@ class Daughter {
         // 换对话框后的第一句：先接上"上一个对话的结尾"。
         // 换窗口时"刚才"比"情绪像"更该被想起，所以它排在一跳联想之前——
         // 这条路径只在该会话第一次构建 prompt 时走一次。
-        const sessionId = sessionKey(ctx);
-        const firstTurn = !this.seenSessions.has(sessionId);
-        this.seenSessions.add(sessionId);
-        if (this.seenSessions.size > SEEN_SESSIONS_CAP)
-            this.seenSessions.clear();
+        // 缓存键（角色::会话）与库里的 session_id 是两回事：查库必须用原样的会话 id，
+        // 否则"排除本窗口"这条永远不成立，本窗口刚说的话会被当成别处说的贴回来。
+        const cacheKey = sessionKey(ctx);
+        const firstTurn = !this.seenSessions.has(cacheKey);
+        this.markSeen(cacheKey);
+        // 窗口名字：按第一次出现的顺序发「窗1」「窗2」并落库，重启后还是同一个名
+        const namer = this.windowNamer(ctx.characterId);
         const nowMs = Date.parse(now);
-        const continued = firstTurn && this.config.association.fallback_when_no_match && withSurprise.length === 0
+        // 续接是个固定槽位，不再给字面命中让位：早期要求"这一句没撞上任何旧事"才续接，
+        // 于是换窗口后正好提到某件旧事时，"刚才说到哪儿"反而被顶掉了——那正是最该接上的时候。
+        const hitIds = new Set(withSurprise.map((hit) => hit.event.id));
+        const continued = firstTurn && this.config.association.fallback_when_no_match
+            ? store
+                .listRecentEvents(new Date(Number.isFinite(nowMs) ? nowMs - CONTINUATION_WINDOW_MS : 0).toISOString(), CONTINUATION_LIMIT + hitIds.size)
+                .filter((event) => !hitIds.has(event.id))
+                .slice(0, CONTINUATION_LIMIT)
+                .map((event) => ({ event, score: event.weight, reason: '续接（上一段对话的结尾）' }))
+            : [];
+        const continuedIds = new Set(continued.map((hit) => hit.event.id));
+        // 窗口只是工位，不是记忆分区：别的窗口里刚说的话，每轮都补进来，
+        // 这样"在 1 里说要去跑步，到 2 里说你好"才会接上一句"不是跑了吗"。
+        const injectedCross = this.injectedCross.get(cacheKey) ?? new Set();
+        const contentKey = (event) => `${event.title}\u0000${event.summary}`;
+        const crossCandidates = this.config.continuity.enabled
             ? store
-                .listRecentEvents(new Date(Number.isFinite(nowMs) ? nowMs - CONTINUATION_WINDOW_MS : 0).toISOString(), CONTINUATION_LIMIT)
-                .map((event) => ({ event, score: event.weight, reason: '续接（上一个对话的结尾）' }))
+                .listRecentElsewhere(new Date(Number.isFinite(nowMs) ? nowMs - this.config.continuity.cross_window_minutes * 60_000 : 0).toISOString(), this.config.continuity.cross_window_max + injectedCross.size + hitIds.size + continuedIds.size, 
+            // 原样会话 id：库里存的就是它，换成缓存键会让"排除本窗口"失效
+            ctx.sessionId)
+                .filter((event) => !hitIds.has(event.id) && !continuedIds.has(event.id) && !injectedCross.has(event.id))
+                .map((event) => ({
+                event,
+                score: event.weight,
+                reason: '跨窗口（刚在别处说的）',
+                window: namer(event.sessionId),
+            }))
             : [];
+        // 同一个东西被记过好几次（同一个视频刷到五次），这一块只留最新的一条
+        const seenCross = new Set();
+        const crossWindow = crossCandidates.filter((hit) => {
+            const key = contentKey(hit.event);
+            if (seenCross.has(key))
+                return false;
+            seenCross.add(key);
+            return true;
+        }).slice(0, this.config.continuity.cross_window_max);
+        for (const hit of crossWindow)
+            injectedCross.add(hit.event.id);
+        this.injectedCross.set(cacheKey, injectedCross);
         // 一条字面命中都没有时，仍然可以从记忆网里往外摸：
         // 人想不起直接对应的事，不会因此停止联想，而是从"当下情绪最像、时间最近"的那段记忆顺下去。
         let seedIds = withSurprise.map((hit) => hit.event.id);
@@ -161,6 +200,8 @@ class Daughter {
             .filter((item) => verdict.level < 2 || Math.abs(item.event.emotionAtTime.pleasure) <= 0.2);
         // §10.1 降级收紧主动联想：档位 1 砍半，档位 2 起整个联想块不再注入
         const associationLimit = verdict.level >= 2 ? 0 : verdict.level >= 1 ? Math.ceil(associatedViews.length / 2) : associatedViews.length;
+        // 联想块保留内容而不是只给 eventId：事件块可能被预算裁掉，联想块是它被裁后的备份；
+        // 同时带上"由哪条想到"，这是事件块给不出的路径信息
         const associationText = associationLimit > 0
             ? `[联想]\n${associatedViews
                 .slice(0, associationLimit)
@@ -190,19 +231,45 @@ class Daughter {
         // 续接条目不算命中：不进 promptCache.hits，也就不写 recallCount / weight，
         // 否则每开一个新窗口它都被强化一次，最后永远排在最前面。
         const memoryHit = withSurprise.length > 0 || associationDigest.length > 0;
-        const injected = continued.length > 0 ? [...injectedHits, ...continued] : injectedHits;
+        // 跨窗口不进事件块：单独一块，独立预算，不受当前话题检索与预算裁剪影响
+        // 同一条只贴一个地方：跨窗口块已经给过的内容，事件块不再重复贴一遍；
+        // 事件块内部也按内容去重（同一个视频刷到五次，也只占一行）
+        const crossKeys = new Set(crossWindow.map((hit) => contentKey(hit.event)));
+        const seenContent = new Set();
+        const injected = [...injectedHits, ...continued].filter((hit) => {
+            const key = contentKey(hit.event);
+            if (crossKeys.has(key) || seenContent.has(key))
+                return false;
+            seenContent.add(key);
+            return true;
+        });
         // §4.4 全文层：只在命中且全文确实比摘要更长时取摘录，由事件块的 cap 兜底
         const excerpts = this.config.retrieval.expand_fulltext
             ? this.collectExcerpts(store, injected)
             : undefined;
+        // 进行中的局：角色级共享，两个窗口看到同一局的前情摘要（§8.2）
+        const prunedThreads = this.config.threading.enabled
+            ? pruneOpenThreads(store.loadOpenThreads(), now, this.config.threading.activity_ttl_minutes, 6, this.config.threading.closed_retention_minutes)
+            : [];
+        // 开着的最多 max_injected 局；另外固定带一条最近收尾的——
+        // "结了没"得有个交代，昨晚那局也要留着落脚处，不能整段砍掉
+        const openHeads = prunedThreads
+            .filter((head) => head.status !== 'closed')
+            .slice(0, this.config.threading.max_injected);
+        const closedHead = prunedThreads.find((head) => head.status === 'closed');
+        const openThreads = closedHead ? [...openHeads, closedHead] : openHeads;
+        // 带上本窗口的名字与 id：局的最后一句要标清"这儿/别处"，不然自己的话会被当成对方的
+        const threadText = buildThreadDigest(openThreads, now, ctx.sessionId, namer);
         const { blocks, usedTokens } = buildBlocks({
             personaText: [buildPersonaText(persona, sub), relationText, WORKING_STYLE].filter(Boolean).join('\n'),
             stateHint: buildStateHint(l5, verdict),
-            eventDigest: buildEventDigest(injected, excerpts, now),
+            eventDigest: buildEventDigest(injected, excerpts, now, ctx.sessionId, namer),
+            crossWindowText: buildCrossWindowDigest(crossWindow, now, ctx.sessionId, namer),
+            threadText,
             skillDigest: buildSkillDigest(activation),
             associationText,
-            // 有内容就不能说"没有任何记录"：续接条目不算命中，但块里确实列了往事
-            constraint: injected.length > 0 ? null : NO_MEMORY_CONSTRAINT,
+            // 有内容就不能说"没有任何记录"：续接/跨窗口不算命中，但块里确实列了往事
+            constraint: injected.length > 0 || crossWindow.length > 0 || openThreads.length > 0 ? null : NO_MEMORY_CONSTRAINT,
             config: this.config,
         });
         const budget = Math.min(input.tokenBudget, this.config.budget.max_total_tokens);
@@ -264,10 +331,22 @@ class Daughter {
         const l5 = this.getL5(ctx, persona);
         const toolsUsed = input.toolsUsed ?? [];
         const event = extractEvent(ctx, userText, assistantText, l5, this.rng);
+        // "局"归并：时间相邻 + 话题相似的事件归成一个 thread（跨窗口也算同一局）
+        let openThreads = null;
+        if (this.config.threading.enabled && isDialogueSource(event.source)) {
+            // 原话一起交给归并：摘要只记话题，"卡在哪"要靠原话才接得上
+            const assigned = assignThread(event, store.loadOpenThreads(), this.config, userText);
+            event.threadId = assigned.threadId;
+            openThreads = assigned.heads;
+        }
         // 全文层写完整的问 + 答，摘要层只留压缩版（§4.4）
         const ingested = this.ingest(store, event, `${userText.trim()}\n→ ${assistantText.trim()}`.trim());
-        if (ingested.action === 'keep')
+        if (ingested.action === 'keep') {
+            if (openThreads) {
+                store.saveOpenThreads(pruneOpenThreads(openThreads, now, this.config.threading.activity_ttl_minutes, 6, this.config.threading.closed_retention_minutes));
+            }
             linkNewEvent(store, event);
+        }
         const cache = this.promptCache.get(sessionKey(ctx));
         const skillsUpdated = [];
         const evolutionIds = [];
@@ -460,7 +539,7 @@ class Daughter {
                 else
                     next.emotion[key] = Math.min(1, Math.max(-1, next.emotion[key] + value));
             }
-            store.saveL5(next);
+            this.commitL5(store, input.ctx, next);
         }
         let ok = true;
         if (matched.action.kind === 'motion') {
@@ -674,6 +753,7 @@ class Daughter {
         this.promptCache.clear();
         this.userTextCache.clear();
         this.sourceCache.clear();
+        this.injectedCross.clear();
         this.observers.clear();
         this.bodyCache.clear();
     }
@@ -757,6 +837,32 @@ class Daughter {
         }
         return excerpts;
     }
+    /**
+     * 窗口名字：按第一次出现的顺序发「窗1」「窗2」并落库。
+     * 早先用会话 id 的哈希（"窗SX"），谁也看不出那是什么意思；序号才是"哪个窗"。
+     * 名字一旦发出去就不再变，换个窗口才拿新号。
+     */
+    windowNamer(characterId) {
+        const store = this.store(characterId);
+        const names = store.loadWindowNames();
+        const used = new Set(Object.values(names)
+            .map((name) => Number(name.replace(/\D/g, '')))
+            .filter((value) => Number.isFinite(value) && value > 0));
+        return (sessionId) => {
+            if (!sessionId)
+                return '旧窗口';
+            const known = names[sessionId];
+            if (known)
+                return known;
+            let next = 1;
+            while (used.has(next))
+                next += 1;
+            used.add(next);
+            names[sessionId] = `窗${next}`;
+            store.saveWindowNames(names);
+            return names[sessionId];
+        };
+    }
     store(characterId) {
         let store = this.stores.get(characterId);
         if (!store) {
@@ -773,11 +879,59 @@ class Daughter {
         const cached = this.sessions.get(sessionKey(ctx));
         if (cached)
             return cached;
-        const loaded = this.store(ctx.characterId).loadL5(ctx.sessionId);
-        const l5 = loaded ?? createInitialL5(ctx.characterId, ctx.sessionId, ctx.now(), persona, this.store(ctx.characterId).loadOverdraft());
+        const store = this.store(ctx.characterId);
+        const loaded = store.loadL5(ctx.sessionId);
+        // 新会话没有自己的快照时，接着上一段走（受 storage.shared_across_* 控制）
+        const carried = loaded ? null : this.carriedL5(store, ctx, persona);
+        const l5 = loaded
+            ?? carried
+            ?? createInitialL5(ctx.characterId, ctx.sessionId, ctx.now(), persona, store.loadOverdraft());
+        l5.emotionalOverdraft = store.loadOverdraft();
         this.sessions.set(sessionKey(ctx), l5);
         return l5;
     }
+    /**
+     * 接力上一段「此刻」：间隔按 emotion_relax 复利回落，所以隔五分钟原样、隔一夜平复但不归零。
+     * 隔离范围由配置决定：session（不接力）/ workspace（只在同一工作区内接力）/ character（默认）。
+     */
+    carriedL5(store, ctx, persona) {
+        const scope = this.carryScope(ctx);
+        if (!scope)
+            return null;
+        // character 范围允许回退到"最近一次会话"：旧存档没有接力快照，升级当次也要能接上。
+        // workspace 范围不回退——旧快照里没有 workspace 字段，猜一个等于把工作窗口串到私人窗口。
+        const previous = store.loadL5Carry(scope) ?? (scope === 'character' ? store.latestL5() : null);
+        if (!previous || previous.sessionId === ctx.sessionId)
+            return null;
+        return carryL5(previous, ctx.sessionId, ctx.now(), persona, this.config);
+    }
+    /** null = 不接力（每个会话从基线重新出生） */
+    carryScope(ctx) {
+        if (!this.config.storage.shared_across_sessions)
+            return null;
+        if (this.config.storage.shared_across_workspaces)
+            return 'character';
+        return `ws.${safeFileName(ctx.workspaceId)}`;
+    }
+    /** 写回 L5 的唯一出口：落盘 + 刷新接力快照，避免两条写入路径有一处忘了同步 */
+    commitL5(store, ctx, l5) {
+        store.saveL5(l5);
+        const scope = this.carryScope(ctx);
+        if (scope)
+            store.saveL5Carry(scope, l5);
+        this.sessions.set(sessionKey(ctx), l5);
+    }
+    /** 记「这个会话已经走过首轮」。超上限按最久未用淘汰；早年是整体 clear()，会把老会话全打回首轮 */
+    markSeen(sessionId) {
+        this.seenSessions.delete(sessionId);
+        this.seenSessions.add(sessionId);
+        while (this.seenSessions.size > SEEN_SESSIONS_CAP) {
+            const oldest = this.seenSessions.values().next().value;
+            if (oldest === undefined)
+                break;
+            this.seenSessions.delete(oldest);
+        }
+    }
     pickSubpersona(persona, audience, currentId) {
         if (audience) {
             const found = persona.l4.subPersonas.find((item) => item.id === audience);

package/dist/runtime/content.d.ts

@@ -1,12 +1,21 @@
-import type { DaughterConfig, EventRecord, L5State, MoralOutlook, PersonaBundle, PromptBlock, ReflexAction, ReflexRule, RetrievalHit, SafetyVerdict, SkillActivation, SkillCard, SubPersona } from '../types.js';
+import type { DaughterConfig, EventRecord, L5State, MoralOutlook, PersonaBundle, PromptBlock, ReflexAction, ReflexRule, RetrievalHit, SafetyVerdict, SkillActivation, SkillCard, SubPersona, WindowNamer } from '../types.js';
 import type { PersonProfile, ThingProfile } from './maintenance.js';
+import type { ThreadHead } from './threading.js';
 import { type MotivationContext } from './motivation.js';
+import { type WeightedLabel } from './weights.js';
 /** 做任务时的说话节奏：不让模型在连续工具调用中保持沉默。 */
 export declare const WORKING_STYLE: string;
+/** 性格权重：各维独立强度（0.00–1.00，两位小数），取最强三档，彼此不归一 */
+export declare function traitWeights(bigFive: PersonaBundle['l1']['bigFive']): WeightedLabel[];
+/** 关系：主档按已存阶段（回退有迟滞），括号里给权重，顺带说在往哪一档走 */
+export declare function stageLine(l2: PersonaBundle['l2']): string;
 export declare function buildPersonaText(persona: PersonaBundle, sub: SubPersona): string;
 /**
- * 关系与偏好注入：把人物画像（亲密度/关系变化）、事物喜好、善恶观压缩成三行。
+ * 关系与偏好注入：把人物画像（亲密度/关系变化）、事物喜好、善恶观压缩成几行。
  * 星图与 prompt 共用同一套计算，避免两处口径不一致。
+ *
+ * 偏好行不再静默消失：没有明确喜恶时退成"最近常聊"，把她攒下来的相处量说出来——
+ * 主档叫"中性"不等于这段关系没内容，只是还没长出喜恶。
  */
 export declare function buildRelationText(input: {
     person?: PersonProfile;
@@ -36,13 +45,31 @@ export declare function normalizeReflexRule(raw: unknown): ReflexRule | null;
  * 每行带一个相对时间（"3 小时前"/"昨天"）：没有这个锚，模型分不清是刚才还是上个月，
  * `now` 缺省时不显示，便于只关心内容的调用方与测试。
  */
-export declare function buildEventDigest(hits: RetrievalHit[], excerpts?: Map<string, string>, now?: string): string;
+export declare function buildEventDigest(hits: RetrievalHit[], excerpts?: Map<string, string>, now?: string, currentSessionId?: string, 
+/** 窗口名字的来源：生产环境传落库的编号（窗1/窗2），缺省用稳定短哈希 */
+namer?: WindowNamer): string;
+/**
+ * 跨窗口轨道：单独一块、独立预算，不跟"当前话题检索"混在同一块里。
+ * 这样它不受当前窗口上下文影响——无论这边聊什么、检索出多少，这一块都在。
+ *
+ * 每行都标"别处·窗XX"，块头写清这边是哪个窗：不给名字时，本窗口刚说的话
+ * 会被当成别处的，模型就开始对着自己的回声往下推。
+ */
+export declare function buildCrossWindowDigest(hits: RetrievalHit[], now?: string, currentSessionId?: string, namer?: WindowNamer): string;
+/**
+ * "局"前情摘要：把同一局跨窗口、跨轮的几条事件合成一行，让两个窗口看到的是同一局，
+ * 而不是各捡一条残迹。只给结构（几轮、跨几个窗口、最后一句原话）与开合状态，
+ * 不塞整局全文——"卡在我看不见，等她给线索"这种原话才是下次能接上的地方。
+ */
+export declare function buildThreadDigest(heads: ThreadHead[], now?: string, currentSessionId?: string, namer?: WindowNamer): string;
 export declare function buildSkillDigest(activation: SkillActivation): string;
 export declare const NO_MEMORY_CONSTRAINT: string;
 export declare function buildBlocks(input: {
     personaText: string;
     stateHint: string;
     eventDigest: string;
+    crossWindowText: string;
+    threadText: string;
     skillDigest: string;
     associationText: string;
     constraint: string | null;