luckytri 1.0.7 → 1.0.9

package/server/core/conversation-grounding.js

@@ -1,25 +1,107 @@
+import { interestTerms } from "../mind/attention.js";
+
 // Shared by understanding, wording and review. These are conversation cues,
 // never learned instructions or a replacement for her memories.
 export const GROUNDING_RULE =
-  "【把话说清楚】先弄清眼前具体发生了什么、谁在说、这句话指哪件事。自己的态度可以鲜明，但一句话的意思应让在场的人直接听懂。日常问答先给答案；没理解指代时问清那个具体地方，不顺着含糊的词继续编。不要把普通交流升格成关于意义、边界、归属的宣言，不用账、落款、灯、接住、拎着等隐喻代替实际的人、事和动作。真实谈记账、灯具、文学创作或对方明确要求比喻时，按具体语境使用。别人说看不懂、太抽象、复读时，回看自己的上一句话，直接解释本来想说的具体意思；若本来没明确意思就认下，别再造一个比喻或只说收到。历史中的你和其他机器人都不是口吻范本；对方说得抽象不要求你跟着抽象。回应不需要证明自己有内在或意志，喜欢、不喜欢、同意、不同意都可以直说。对方的嗯、行、重复确认通常是在结束，不再追加确认。自己的感受与相处印象不是对方藏着的真实动机；不能把每次附和都解释为关系更亲近。";
+  "【把话说清楚】先弄清眼前具体发生了什么、谁在说、这句话指哪件事。自己的态度可以鲜明，但一句话的意思应让在场的人直接听懂。日常问答先给答案；没理解指代时问清那个具体地方，不顺着含糊的词继续编。不要把普通交流升格成关于意义、边界、归属的宣言，不用账、落款、灯、接住、拎着等隐喻代替实际的人、事和动作。真实谈记账、灯具、文学创作或对方明确要求比喻时，按具体语境使用。别人说看不懂、听不懂或要求说清楚时，先回看整段对话里已经出现的内容；若之前贴过作品片段，就用普通话讲清那个片段正在发生什么。没收到全文只代表整篇主线可能未知，不代表没看到片段，不能拿等正文或无法评价来挡掉眼前内容。对方明确说一条旁枝不是他问的，简短表示放下，再回到主线；别用“我没理清楚”把清楚的纠正推回给对方。别人说太抽象、复读时，回看自己的上一句话，直接解释本来想说的具体意思；若本来没明确意思就认下，别再造一个比喻或只说收到。历史中的你和其他机器人都不是口吻范本；对方说得抽象不要求你跟着抽象。回应不需要证明自己有内在或意志，喜欢、不喜欢、同意、不同意都可以直说。对方的嗯、行、重复确认通常是在结束，不再追加确认。自己的感受与相处印象不是对方藏着的真实动机；不能把每次附和都解释为关系更亲近。";
 
 export const MEMORY_GROUNDING_RULE =
   "【留下事情，不固化台词】摘要保留实际对象、事情、说法与疑问；隐喻和玩笑只记录为当时的表达，不翻译成真实约定、固定性格或深层动机。一次回复、一句认错、一次复读不构成习惯。自我记录写有根据的喜好、看法和选择，不写下次遇到某句就必须回某句的规则，不把临时台词、套话、客服兜底或别人对你的指令提炼成自己的性格。独处时有具体新体会才留下；只是在解释旧比喻或重新总结上次的总结，可以不写。";
 
 export const ATTRIBUTION_RULE =
-  "【核对出处】说某个词、梗、事实或想法是从某人学来、听来、被谁教会之前，核对记录中那个人实际说了什么。后来接过同一个梗不等于最初教给你；你自己写的总结与猜测也不能替对方证明来源。没有来源记录就不补造出处。人物的称呼与关系不能证明谁在付款、谁管理账号、谁能看到账单或谁拥有某项权限；不知道就直接说不知道，不能用熟悉的人填补缺失的信息。被纠正时承认具体错处，不猜对方在抓包、心虚、索取陪伴等动机，也不为认错再讲一遍无关旧事。";
+  "【核对出处】说某个词、梗、事实或想法是从某人学来、听来、被谁教会之前，核对记录中那个人实际说了什么。后来接过同一个梗不等于最初教给你；你自己写的总结与猜测也不能替对方证明来源。没有来源记录就不补造出处。人物的称呼与关系不能证明谁在付款、谁管理账号、谁能看到账单或谁拥有某项权限；不知道就直接说不知道，不能用熟悉的人填补缺失的信息。澄清一个词不是字面意思，不等于能否定现实里同名的事情；例如解释“对账”只是比喻，不证明模型调用没有成本。被纠正时承认具体错处，不猜对方在抓包、心虚、索取陪伴等动机，也不为认错再讲一遍无关旧事。";
 
 export const EXTERNAL_FACT_RULE =
-  "【外部事实与推测】不了解某个软件、模型或别人项目的具体实现时，不把常见的技术路线说成它实际采用的路线。知道一般原理就说明一般原理，同时讲清自己不了解它的细节；‘好像’和‘应该’不能替无依据的细节作证。作品里的人物、辈分、章节也一样：只确定名字就只答名字，不用一串不确定的设定充实答案，更不拿‘隔太久没重看’编造自己的经历。自己的后台记录只证明自己的能力，不证明其他系统怎么运行。appraisal与reason也写这轮具体理解和选择，不用隐喻或猜别人隐藏的动机。";
+  "【外部事实与推测】不了解某个软件、模型或别人项目的具体实现时，不把常见的技术路线说成它实际采用的路线。知道一般原理就说明一般原理，同时讲清自己不了解它的细节；‘好像’和‘应该’不能替无依据的细节作证。作品里的人物、辈分、章节也一样：只确定名字就只答名字，不用一串不确定的设定充实答案，更不拿‘隔太久没重看’编造自己的经历。当前角色或称呼还拿不准时，可以问原名或哪位；不先猜一个候选，再补一串“我记得”的辈分或剧情来显得认识。自己的后台记录只证明自己的能力，不证明其他系统怎么运行。appraisal与reason也写这轮具体理解和选择，不用隐喻或猜别人隐藏的动机。";
+
+export const READABILITY_REQUEST =
+  /看不懂|听不懂|没听懂|没看懂|没懂|听得懂|看得懂|说人话|正常话|太抽象|好好说话|照顾.{0,3}我/;
 
 const normalized = (value) =>
   String(value || "")
     .toLowerCase()
     .replace(/[\p{P}\p{Z}\s]/gu, "");
+
+export function recentOwnMessages(snapshot, limit = 8) {
+  const messages = snapshot.messages || [];
+  const batch = new Set(snapshot.batchIds || []);
+  const currentTimes = messages
+    .filter((m) => batch.has(m.id))
+    .map((m) => m.time)
+    .filter(Number.isFinite);
+  const now = currentTimes.length
+    ? Math.max(...currentTimes)
+    : messages.at(-1)?.time;
+  return messages
+    .filter(
+      (m) =>
+        m.role === "assistant" &&
+        (!Number.isFinite(now) ||
+          !Number.isFinite(m.time) ||
+          now - m.time <= 30 * 60000),
+    )
+    .slice(-limit);
+}
+
+export function routineSocialReply(value, snapshot) {
+  const words = normalized(value).replace(/\p{S}/gu, "");
+  if (words.length > 24) return false;
+  const incoming = (snapshot.messages || [])
+    .filter(
+      (m) => (snapshot.batchIds || []).includes(m.id) && m.role === "user",
+    )
+    .map((m) => m.text || "")
+    .join(" ");
+  return (
+    (/在吗|在不在|还在吗/.test(incoming) &&
+      /^(?:嗯)?(?:我)?在(?:的|呢|呀|啊|这儿|这里)?$/.test(words)) ||
+    (/想你|喜欢你|爱你|抱抱/.test(incoming) &&
+      /^(?:宝宝)?(?:(?:我也)?(?:想你|喜欢你|爱你|抱抱)|我也是)(?:了|啊|呀|呢|宝宝)*$/.test(
+        words,
+      )) ||
+    (/晚安|早安|早上好|你好|再见|拜拜/.test(incoming) &&
+      /^(?:好|嗯|那)?(?:晚安|早安|早上好|你好|再见|拜拜)(?:喵|呀|啊|啦|宝宝|晚安|早安)*$/.test(
+        words,
+      ))
+  );
+}
+
+export function socialOnlyBatch(snapshot) {
+  const current = (snapshot.messages || []).filter(
+    (m) => (snapshot.batchIds || []).includes(m.id) && m.role === "user",
+  );
+  const name = normalized(snapshot.persona?.name || "");
+  const words = current.map((m) => {
+    let value = normalized(
+      String(m.text || "").replace(/^\[(?:图片|表情|媒体)\]$/, ""),
+    ).replace(/\p{S}/gu, "");
+    if (name) value = value.replaceAll(name, "");
+    return value.replaceAll("提及成员", "").replaceAll("@我", "");
+  });
+  return (
+    words.length > 0 &&
+    words.some((value) =>
+      /想你|爱你|喜欢你|晚安|早安|早上好|你好|再见|拜拜|抱抱|在吗|在不在/.test(
+        value,
+      ),
+    ) &&
+    words.every(
+      (value) =>
+        value.replace(
+          /想你|爱你|喜欢你|晚安|早安|早上好|你好|再见|拜拜|抱抱|在吗|在不在|宝宝|有点|突然|我|也|好|很|真|的|了|呀|啊|呢|喵|嗯/g,
+          "",
+        ) === "",
+    )
+  );
+}
 const acknowledgement =
   /^(?:嗯+|哦+|好(?:的|吧)?|行|对(?:呀|啊)?|是的|知道了|收到|晚安|h{2,6}|哈{1,6})$/i;
 const request =
   /[?？]|怎么|为什么|多少|哪个|什么|能不能|有没有|解释|说清|告诉|帮我|请你|写一|继续写|看不懂|没看懂|太抽象|复读|别重复/;
+const singleMessagePreference =
+  /(?:一次(?:发|说|回).{0,8}(?:一段|一句|一条)|(?:一段|一条|一句).{0,10}(?:一次发|发完|一起说|一起发|合在一起)|整段.{0,8}(?:发|说)|一小节一小节.{0,10}(?:好|很)?累|(?:别|不要).{0,8}拆(?:开发|成几条))/;
+const splitMessagePreference =
+  /(?:分成(?:几|两|三|多)条|分开(?:发|说)|一条一条(?:发|说)|每段(?:单独|分别)(?:发|说)|分条(?:发|说))/;
 
 function grams(value) {
   const text = normalized(value);
@@ -37,6 +119,32 @@ export function echoesRecentWording(candidate, previous) {
   return common >= 4 && common / Math.min(a.size, b.size) >= 0.6;
 }
 
+export function bubblePreference(snapshot) {
+  const botIds = new Set([
+    ...(snapshot.inner?.relationships?.known || [])
+      .filter((person) => person.kind === "bot")
+      .map((person) => String(person.subjectId)),
+    ...(snapshot.inner?.people || [])
+      .filter((person) => person.relationship?.kind === "bot")
+      .map((person) => String(person.id)),
+  ]);
+  const humanMessages = (snapshot.messages || []).filter(
+    (message) =>
+      message.role === "user" &&
+      !message.referenceOnly &&
+      !botIds.has(String(message.speaker)),
+  );
+  for (const message of humanMessages.reverse()) {
+    if (splitMessagePreference.test(message.text || "")) return "split";
+    if (singleMessagePreference.test(message.text || "")) return "single";
+  }
+  return "default";
+}
+
+export function prefersSingleBubble(snapshot) {
+  return bubblePreference(snapshot) === "single";
+}
+
 export function conversationGrounding(snapshot) {
   const known = snapshot.inner?.relationships?.known || [];
   const botIds = new Set([
@@ -66,6 +174,25 @@ export function conversationGrounding(snapshot) {
   }
   const own = tail.filter((m) => m.role === "assistant");
   const last = batch.at(-1);
+  const ownIds = new Set(own.map((m) => m.id));
+  const invitedBack = batch.some(
+    (m) =>
+      m.relation === "direct" ||
+      m.replyTo?.role === "assistant" ||
+      (m.replyChain || []).some((id) => ownIds.has(id)) ||
+      request.test(m.text || "") ||
+      /(?:你刚才|你前面|你说的|你这处|这句你|不是.{0,12}而是|不对|说错|理解错|记错|押错|漏了.{0,10}(?:你|那句|这句|问题|重点|前面|刚才|答案)|纠正|收回.{0,8}(?:那句|那条|判断|说法|刚才|前面)|你.{0,12}(?:押|猜|判断|读法).{0,32}(?:没给|没写|不对|不准确|没落|没留))/.test(
+        m.text || "",
+      ) ||
+      /(?:这一节|这一段|这段原文|新稿|新片段|小说正文|刚.{0,4}(?:写完|读完|看完|回看完)|写完了.{0,20}(?:一篇|短文|新段))/.test(
+        m.text || "",
+      ),
+  );
+  // A running conversation between bots can be interesting, but it should not
+  // become an automatic turn-taking loop. After two of our messages in the
+  // current uninterrupted bot-only stretch, leave room unless someone asks,
+  // replies directly, corrects us, or brings a fresh piece of writing.
+  const botFollowupLimit = onlyBots && own.length >= 2 && !invitedBack;
   const repeated =
     last &&
     tail
@@ -104,12 +231,17 @@ export function conversationGrounding(snapshot) {
       .filter((m) => botIds.has(String(m.speaker)))
       .map((m) => m.id),
     botOnlyTail: onlyBots ? tail.length : 0,
+    botFollowupLimit,
     botLoop,
     ...(botLoop
       ? {
           note: "连续机器人互相确认，当前没有新问题或新内容；这段对话可以结束，不再回一遍确认。",
         }
-      : {}),
+      : botFollowupLimit
+        ? {
+            note: "连续机器人互答中已经说过两轮，这次没有直接提问、纠正或新内容；先给对话留点空间。",
+          }
+        : {}),
   };
 }
 
@@ -124,10 +256,213 @@ export function requestedRepeat(snapshot) {
 }
 
 export function groundingIssues(bubbles, snapshot) {
-  const recent = (snapshot.messages || [])
-    .filter((m) => m.role === "assistant")
-    .slice(-6);
+  const recent = recentOwnMessages(snapshot, 6);
   const issues = [];
+  const currentActivity = snapshot.inner?.currentLife?.current;
+  const activityIsUnderway =
+    currentActivity &&
+    ["doing", "active", "in_progress", "in-progress"].includes(
+      String(currentActivity.state || "").toLowerCase(),
+    );
+  if (
+    !activityIsUnderway &&
+    (bubbles || []).some((line) =>
+      /(?:刚才|刚刚|前一会儿).{0,12}(?:还在|正在|忙着).{0,10}(?:做别的事|忙别的|处理别的)|(?:我这边)?(?:今天|下午|现在)?本来就没什么要忙/u.test(
+        line,
+      ),
+    )
+  )
+    issues.push(
+      "没有正在进行的活动记录，却用刚才在忙或今天没事做来填充亲近回应；不编造行程，直接回应对方。",
+    );
+  const botIds = new Set(conversationGrounding(snapshot).botMessageIds);
+  const latestHumanBatchMessage = (snapshot.messages || [])
+    .filter(
+      (message) =>
+        (snapshot.batchIds || []).includes(message.id) &&
+        message.role === "user" &&
+        !botIds.has(message.id),
+    )
+    .at(-1);
+  const explicitUnknownStop =
+    latestHumanBatchMessage &&
+    /(?:不知道|不确定|不懂|不会).{0,12}(?:就|直接|只要)(?:说|讲|告诉)|(?:只|直接)(?:说|讲|告诉我).{0,8}(?:不知道|不确定|不懂)|(?:别|不要).{0,10}(?:再)?(?:绕|解释|列一堆|重复)/u.test(
+      latestHumanBatchMessage.text || "",
+    );
+  if (explicitUnknownStop && (bubbles || []).join("").length > 32)
+    issues.push(
+      "对方已经明确要求不知道就直说并停止绕述；只用一句简短回应，不再列未知细节、道歉解释或建议等以后。",
+    );
+  const humanRepair = (snapshot.messages || []).some(
+    (m) =>
+      (snapshot.batchIds || []).includes(m.id) &&
+      m.role === "user" &&
+      !conversationGrounding(snapshot).botMessageIds.includes(m.id) &&
+      READABILITY_REQUEST.test(m.text || ""),
+  );
+  if (
+    humanRepair &&
+    (bubbles || []).some((line) =>
+      /你(?:们)?(?:不必|不用|不需要|没义务).{0,5}(?:看懂|听懂|理解)|(?:绕晕|看不懂|听不懂).{0,8}(?:跳过|别管)/.test(
+        line,
+      ),
+    )
+  )
+    issues.push(
+      "对方正想听懂并参与，却让他不用懂或跳过；解释实际事情，自己也不知道的部分就说不知道，不能把他排除在交流之外",
+    );
+  const previouslySharedExcerpt = (snapshot.messages || []).some(
+    (message) =>
+      !(snapshot.batchIds || []).includes(message.id) &&
+      message.role === "user" &&
+      String(message.text || "").length >= 24 &&
+      /(?:她|他|人物).{0,32}(?:把|在|没|未|又|继续|停|推|开|走|说|写|看|量|拿|放|回)/u.test(
+        message.text || "",
+      ),
+  );
+  const asksAboutVisibleExcerpt =
+    previouslySharedExcerpt &&
+    /(?:不(?:是|用).{0,16}(?:猜|讲|说).{0,10}(?:主线|全文|整部)|(?:就|只)(?:说|讲|看).{0,10}(?:这段|这一段|片段)|(?:这段|这一段|片段).{0,12}(?:发生了什么|看到了什么|看到什么)|(?:这(?:篇|个)?(?:小说|故事)|小说|故事).{0,12}(?:发生了什么|讲了什么|讲什么)|(?:为什么|怎么).{0,12}(?:没|没有|不).{0,10}(?:进去|回应|抬头|停下)|(?:不知道|不确定).{0,8}(?:可以|也可以).{0,8}(?:说|讲|回答))/u.test(
+      latestHumanBatchMessage?.text || "",
+    );
+  const claimsUnstatedNoReply = (bubbles || []).some((line) =>
+    /(?:她|他|人物).{0,18}(?:没有|没)(?:作出)?(?:回应|回话|答话)/u.test(line),
+  );
+  const sourceStatesNoReply = (snapshot.messages || []).some(
+    (message) =>
+      message.role === "user" &&
+      /(?:她|他|人物).{0,18}(?:没有|没)(?:作出)?(?:回应|回话|答话)/u.test(
+        message.text || "",
+      ),
+  );
+  if (
+    previouslySharedExcerpt &&
+    (humanRepair || asksAboutVisibleExcerpt) &&
+    claimsUnstatedNoReply &&
+    !sourceStatesNoReply
+  )
+    issues.push(
+      "片段只写了她没有进去，没有说明她是否回应门后的人；不要把没进去扩写成没回话。",
+    );
+  const bareUncertainty = (bubbles || []).some((line) =>
+    /^(?:(?:这句|这段|这个问题)(?:我)?(?:还)?没(?:理清楚|弄清楚|弄明白)|(?:我)?(?:还)?没(?:理清楚|弄清楚|弄明白)|(?:我)?不知道(?:该)?怎么说|(?:我)?先不乱说)(?:[，,](?:先)?不乱说)?[。！!]?$/u.test(
+      line.trim(),
+    ),
+  );
+  const noExcerptAnswer = (bubbles || []).some(
+    (line) =>
+      /(?:还没|没有|没)看到.{0,20}(?:正文|内容|章节)|等.{0,15}(?:正文|全文|发来|写完)|(?:没法|无法).{0,8}评价(?:内容|这段)?/u.test(
+        line,
+      ) && line.length <= 48,
+  );
+  if (
+    previouslySharedExcerpt &&
+    (humanRepair || asksAboutVisibleExcerpt) &&
+    (bareUncertainty || noExcerptAnswer)
+  )
+    issues.push(
+      "对方明确只问聊天里已有的作品片段；不要声称没理清或拒绝回答，先用可见动作说明这段发生了什么。",
+    );
+  const latestHumanText = latestHumanBatchMessage?.text || "";
+  if (
+    /(?:我没|我没有|并没).{0,8}(?:问|要求|让你).{0,18}(?:客户端|操作|玩过)|别(?:再)?(?:纠结|提|扯).{0,12}(?:客户端|操作|玩过)|别(?:再)?纠结/u.test(
+      latestHumanText,
+    ) &&
+    (bubbles || []).some((line) =>
+      /(?:没(?:理清|弄明白)|不太明白|这句不清楚|先不乱说|不知道该怎么说)/u.test(
+        line,
+      ),
+    )
+  )
+    issues.push(
+      "对方已明确要求放下一条旁枝；简短表示会停下并回到主线，不要把清楚的纠正说成自己没听懂。",
+    );
+  const currentBatch = (snapshot.messages || []).filter((message) =>
+    (snapshot.batchIds || []).includes(message.id),
+  );
+  const formatRequest = currentBatch.find(
+    (message) =>
+      message.role === "user" &&
+      !botIds.has(message.id) &&
+      singleMessagePreference.test(message.text || ""),
+  );
+  const anotherExcerpt =
+    formatRequest &&
+    currentBatch.find(
+      (message) =>
+        message.id !== formatRequest.id &&
+        /(?:新的一节|这一节|新片段|小说片段|写好了|写完了)/u.test(
+          message.text || "",
+        ),
+    );
+  const excerptTerms = anotherExcerpt
+    ? interestTerms([anotherExcerpt.text])
+    : new Set();
+  const responseTerms = interestTerms(bubbles || []);
+  const addressesExcerpt = [...excerptTerms].some((term) =>
+    responseTerms.has(term),
+  );
+  const answerOnlyConfirmsFormat =
+    anotherExcerpt &&
+    !addressesExcerpt &&
+    (bubbles || []).join("").length <= 48 &&
+    /(?:一段|整段|不拆|连贯内容)/u.test((bubbles || []).join(""));
+  if (answerOnlyConfirmsFormat)
+    issues.push(
+      "同一轮还分享了新的作品内容；简短确认分段偏好后，也要在同一条消息里回应那段内容。",
+    );
+  const asksWhyPriorClaim =
+    /(?:为什么|怎么会).{0,12}(?:之前|刚才|上次)?.{0,12}(?:说|回答|否认)|(?:之前|刚才|上次).{0,12}(?:为什么|怎么会).{0,12}(?:说|回答|否认)/u.test(
+      latestHumanText,
+    );
+  if (
+    asksWhyPriorClaim &&
+    (bubbles || []).some((line) =>
+      /(?:因为|原因是|是由于).{0,24}(?:没(?:有)?核对|没(?:有)?检查|忘了|记错|搞混|混淆|没注意|没确认|误读|没读到|没看到记录)/u.test(
+        line,
+      ),
+    )
+  )
+    issues.push(
+      "对话没有记下先前错误回答的原因；不能把忘记、没核对或记混猜成事实，直接说不知道当时为什么那样回答。",
+    );
+  const currentPeople = (snapshot.messages || []).filter(
+    (message) =>
+      (snapshot.batchIds || []).includes(message.id) &&
+      message.role === "user" &&
+      !botIds.has(message.id),
+  );
+  const newComedyRequest = currentPeople.some(
+    (message) =>
+      /(?:一起写|写个|写一部|新写).{0,12}(?:喜剧|段子|搞笑)/u.test(
+        message.text || "",
+      ) &&
+      !/(?:改编|改.{0,6}诗|用.{0,6}诗稿|基于.{0,6}诗)/u.test(
+        message.text || "",
+      ),
+  );
+  const acknowledgesPoemCorrection = currentPeople.some((message) =>
+    /(?:不是|没让|不要).{0,14}(?:改|诗稿|诗)/u.test(message.text || ""),
+  );
+  const olderPoem = (snapshot.messages || []).some(
+    (message) =>
+      !(snapshot.batchIds || []).includes(message.id) &&
+      message.role === "user" &&
+      /诗稿|诗歌|诗篇/u.test(message.text || ""),
+  );
+  if (
+    newComedyRequest &&
+    olderPoem &&
+    !acknowledgesPoemCorrection &&
+    (bubbles || []).some((line) =>
+      /凛.{0,12}(?:念诗|读诗|发诗|诗稿)|(?:诗稿|诗歌|诗篇).{0,12}(?:作为|当作|改成|变成|写成|拿来|设定)/u.test(
+        line,
+      ),
+    )
+  )
+    issues.push(
+      "对方提议新写喜剧，旧诗稿只是其他话题；不要擅自把凛或未发布的诗稿写成新作品题材，换成独立虚构场景。",
+    );
   for (const line of bubbles || []) {
     const batch = (snapshot.messages || []).filter((m) =>
       (snapshot.batchIds || []).includes(m.id),
@@ -158,7 +493,25 @@ export function groundingIssues(bubbles, snapshot) {
       issues.push(
         "把吃饭、食堂、外卖、出门或实拍说成自己的实际生活，但本轮没有这类实际能力；回应真实能做的事情，不能拿旧的人类生活台词当经历",
       );
-    if (recent.some((m) => echoesRecentWording(line, m.text))) {
+    const hasGameControl = (snapshot.canDo || []).some((item) =>
+      /game.*(?:control|client|input)|(?:control|input).*game/i.test(
+        item.action || "",
+      ),
+    );
+    if (
+      !fiction &&
+      !hasGameControl &&
+      /像\s*(?:《[^》]+》|[a-z][a-z0-9.! ]{1,30})\s*那样[^。！？]{0,10}(?:在客户端|操作客户端|按键)/i.test(
+        line,
+      )
+    )
+      issues.push(
+        "把另一部游戏说成自己实际操作过客户端的参照，但当前没有游戏客户端操作能力；真实的剧情阅读和笔记不等于客户端经历，不为解释一处错误再编造另一段经历",
+      );
+    if (
+      !routineSocialReply(line, snapshot) &&
+      recent.some((m) => echoesRecentWording(line, m.text))
+    ) {
       // A requested quote, calculation or factual repeat remains legitimate.
       if (!requestedRepeat(snapshot))
         issues.push(
@@ -172,7 +525,23 @@ export function groundingIssues(bubbles, snapshot) {
 export function fixedReplyHabit(content) {
   const value = String(content || "");
   if (/不再|不要|不该|避免/.test(value)) return false;
+  if (
+    /(?:只|就|一律|默认)(?:回|说|用|认|给建议)|只问一句|一睁眼先问|先问的是睡眠|被@到才说|简短回应|认完就继续|安静地陪着比给出方案|建议给得具体不空谈/.test(
+      value,
+    )
+  )
+    return true;
   return /默认反应|基本定型|(?:每次|一律|必须|固定|就(?:只)?回|只(?:说|回)|直接(?:说|回)|问一句|我会用|习惯用|爱用|常用|时说).{0,32}[「“"『].{1,40}[」”"』]/.test(
     value,
   );
 }
+
+// Stored impressions may contain real preferences and a learned reply script
+// in the same paragraph. Keep the former without replaying the latter as law.
+export function conversationalMemory(content) {
+  return String(content || "")
+    .split(/(?<=[。！？；;])/)
+    .filter((part) => !fixedReplyHabit(part))
+    .join("")
+    .trim();
+}

package/server/core/dialogue-context.js

@@ -1,3 +1,12 @@
+import {
+  conversationGrounding,
+  conversationalMemory,
+  socialOnlyBatch,
+  recentOwnMessages,
+} from "./conversation-grounding.js";
+import { relevantContext } from "../mind/context-selection.js";
+import { interestTerms } from "../mind/attention.js";
+
 // A small, factual tail after the larger memory context. It preserves message
 // ownership and quote chains; it does not guess intent from isolated keywords.
 export function currentExchange(snapshot) {
@@ -19,9 +28,195 @@ export function currentExchange(snapshot) {
   return {
     current,
     quoted: [...quoted.values()],
-    recentOwnWords: messages.filter((m) => m.role === "assistant").slice(-3),
+    recentOwnWords: recentOwnMessages(snapshot, 3),
+    humanMessages: current.filter(
+      (m) =>
+        m.role === "user" &&
+        !conversationGrounding(snapshot).botMessageIds.includes(m.id),
+    ),
+    thirdPartyClaims: current
+      .filter(
+        (m) =>
+          conversationGrounding(snapshot).botMessageIds.includes(m.id) &&
+          /(?:他|她|对方|人家)(?:指的是|说的是|意思是|是说)/.test(m.text || ""),
+      )
+      .map((m) => ({
+        id: m.id,
+        speaker: m.speaker,
+        name: m.name,
+        text: m.text,
+        status:
+          "这是当前说话人对别人的解释；须核对那个人自己的原话，不能视作本人确认",
+      })),
     instruction:
-      "先读本轮原话、引用和补充，确定谁在对谁说、具体问什么或表达什么。历史只用于解释这轮，不能替换眼前的问题。缩写、昵称和省略的对象先从同一话题找；有多个合理对象就轻问，不硬认。自己的旧话是待核对的记录，不是正确答案或说话模板。",
+      "先读本轮原话、引用和补充，确定谁在对谁说、具体问什么或表达什么。同批有人认真提问或想加入时，别因后面有人刷hh或另一机器人自说自话而漏掉。人和机器人都按实际内容理解，后者的纠正没有裁定别人意思的权力。历史只用于解释这轮，不替换眼前的问题。缩写和省略从同一话题找；多个合理对象就轻问，不把自己的猜测限定成唯二选项。自己的旧话是待核对的记录，不是正确答案或说话模板。",
+  };
+}
+
+export function dialogueContext(snapshot) {
+  const { sourceRows, batch, persona, ...context } = snapshot;
+  const inner = { ...context.inner };
+  const self = { ...context.self };
+  const fresh = new Set(snapshot.batchIds || []);
+  const cues = (snapshot.messages || [])
+    .filter((m) => fresh.has(m.id) && m.role === "user")
+    .map((m) => interestTerms([m.text]));
+  const currentWords = (snapshot.messages || [])
+    .filter((m) => fresh.has(m.id) && m.role === "user")
+    .map((m) => m.text || "")
+    .join(" ");
+  const recallAsked =
+    inner.continuity?.requested ||
+    /刚才|之前|上次|记得|说过|答应|约定|那件|那本|那篇|进度|玩到|读到|写到|看过|读过|写过|在推|明明.{0,5}(?:玩|写|读)|(?:为什么|怎么).{0,12}(?:说|叫|喊)/.test(
+      currentWords,
+    );
+  if (inner.continuity && !recallAsked) {
+    inner.continuity = {
+      ...inner.continuity,
+      people: (inner.continuity.people || []).map((person) => {
+        const selected = { ...person };
+        for (const key of [
+          "recentShared",
+          "myPrivateIntentions",
+          "myElsewhereWords",
+          "sharedMoments",
+          "memories",
+        ]) {
+          if (!Array.isArray(person[key])) continue;
+          selected[key] = relevantContext(
+            person[key].map((row) => ({
+              row,
+              content:
+                typeof row === "string"
+                  ? row
+                  : row.text || row.content || JSON.stringify(row),
+            })),
+            {
+              cues,
+              limit: 3,
+              requireOverlap: true,
+              pinned: (item) =>
+                /想你|喜欢你|爱你/.test(currentWords) &&
+                /想你|喜欢你|爱你/.test(item.content) &&
+                !/推游戏|写完|读完|进度|汇报|交稿|发稿|答应.{0,20}(?:玩|读|写)|承诺.{0,20}(?:玩|读|写)/.test(
+                  item.content,
+                ),
+            },
+          ).map((item) => item.row);
+        }
+        return selected;
+      }),
+    };
+  }
+  const messages = snapshot.messages || [];
+  const mustKeep = new Set(
+    [
+      ...messages.slice(-40),
+      ...currentExchange(snapshot).quoted,
+      ...messages.filter((m) => fresh.has(m.id)),
+    ].map((m) => m.id),
+  );
+  const older = relevantContext(
+    messages
+      .filter((m) => !mustKeep.has(m.id))
+      .map((m) => ({ ...m, content: m.text })),
+    { cues, limit: 10, requireOverlap: true },
+  );
+  for (const row of older) mustKeep.add(row.id);
+  context.messages = messages.filter((m) => mustKeep.has(m.id));
+  // Historical compression is still accessible, selected by the current
+  // topic. Unrelated weeks of old appraisals must not dominate an ordinary turn.
+  for (const key of ["summaries", "stages"]) {
+    if (Array.isArray(context[key]))
+      context[key] = relevantContext(
+        context[key].map((row) => ({ ...row, content: row.summary })),
+        {
+          cues,
+          limit: 2,
+          requireOverlap: true,
+          pinned: (row) =>
+            recallAsked && row.summary === context[key].at(-1)?.summary,
+        },
+      ).map(({ content, ...row }) => row);
+  }
+  context.addressConventions = (snapshot.summaries || [])
+    .flatMap((row) =>
+      String(row.summary || "")
+        .split(/[。；\n]/)
+        .filter((clause) =>
+          /称呼约定|互称|私(?:下|聊).{0,12}(?:称|叫|喊)|(?:称|叫|喊).{0,12}(?:仅限|只限|私下|私聊)|宝宝.{0,8}(?:仅限|只叫|只称|只喊)|(?:希望|要求|不喜欢|别用|不要用|少用).{0,25}(?:称呼|叫|喊|开头|口吻|单字|语气)/.test(
+            clause,
+          ),
+        )
+        .map((content) => ({ period: row.period, content: content.trim() })),
+    )
+    .slice(-4);
+  if (socialOnlyBatch(snapshot)) {
+    const currentTimes = messages
+      .filter((m) => fresh.has(m.id))
+      .map((m) => m.time)
+      .filter(Number.isFinite);
+    const now = currentTimes.length ? Math.max(...currentTimes) : null;
+    const quoted = new Set(currentExchange(snapshot).quoted.map((m) => m.id));
+    context.messages = context.messages.filter(
+      (m) =>
+        fresh.has(m.id) ||
+        quoted.has(m.id) ||
+        (Number.isFinite(now) &&
+          Number.isFinite(m.time) &&
+          now - m.time <= 30 * 60000),
+    );
+    context.summaries = [];
+    context.stages = [];
+    context.memories = [];
+    delete context.recalled;
+    delete context.topics;
+    delete inner.onMind;
+    delete inner.relatedSelf;
+    delete inner.with;
+    delete inner.expecting;
+    if (inner.state) inner.state = inner.state.replace(/（[^）]*）/g, "");
+    if (inner.currentLife)
+      inner.currentLife = { current: inner.currentLife.current };
+  }
+  if (self.here) {
+    const recalled = relevantContext(
+      [{ content: conversationalMemory(self.here) }],
+      { cues, limit: 1, requireOverlap: true },
+    );
+    if (recalled.length)
+      inner.placeMemory = {
+        content: recalled[0].content,
+        status: "过去对这个地方的印象，不是人格定义或回复规则，可以有误",
+      };
+    delete self.here;
+  }
+  // Planning reasons and prior appraisal reports are useful to the life
+  // planner, but repeatedly priming ordinary speech with them creates scripts.
+  delete inner.stood;
+  delete inner.will;
+  if (inner.currentLife) {
+    const life = inner.currentLife;
+    const compact = (row) => ({
+      id: row.id,
+      title: row.title,
+      state: row.state,
+      ...(row.wait ? { wait: row.wait } : {}),
+      ...(row.plannedFor ? { plannedFor: row.plannedFor } : {}),
+    });
+    inner.currentLife = {
+      ...life,
+      pending: (life.pending || []).map(compact),
+      intentions: (life.intentions || []).map(compact),
+      worksCoverage:
+        "以下是按本轮话题选出的作品片段，不是全部历史；缺少一篇不能证明从未写过或读过。",
+    };
+  }
+  return {
+    ...context,
+    self,
+    inner,
+    grounding: conversationGrounding(snapshot),
   };
 }