luckytri 1.3.0 → 1.3.2

package/docs/en/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 # Changelog
 
+## 1.3.2 — 2026-10-14
+
+- Stop filling replies with mechanical fallback phrases after repeated validation failures. Ordinary turns stay quiet; clear crisis turns retain a care response.
+- Avoid treating public identity introductions as private-memory leaks, keep recorded open kinship from being denied by old banter or summaries, and leave life wishes and progress out of affectionate replies.
+- Keep @ mentions attached to their intended message bubble, including when an @-only empty bubble is removed.
+
+## 1.3.1 — 2026-10-14
+
+- Fix foreground shutdown after updates on Linux and macOS by recognizing unreaped zombie processes as stopped, so the supervisor cannot wait forever. Add a POSIX zombie-process regression test.
+
 ## 1.3.0 — 2026-10-14
 
 - Add optional speech output and speech recognition through Volcengine and OpenAI-compatible services. Voice stays off by default; she chooses line by line whether to speak or sing. Incoming voice can be transcribed, with text fallback when recognition fails.

package/docs/zh/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 # 版本记录
 
+## 1.3.2 — 2026-10-14
+
+- 回复两次仍未通过校验时，不再用机械短句填空；普通回合保持安静，明确的危机回合仍会给出关心回应。
+- 减少公开身份介绍被误判为泄露私密记忆，也避免旧玩笑或总结否认已经公开的亲属关系；表达想念时不再带入生活愿望与进度。
+- 修正多气泡消息中的 @ 分配，并覆盖清除空 @ 气泡后的提及错位。
+
+## 1.3.1 — 2026-10-14
+
+- 修正 Linux 与 macOS 的前台实例更新后停止逻辑：将未回收的僵尸进程识别为已退出，避免监管进程永久等待；增加 POSIX 僵尸进程回归测试。
+
 ## 1.3.0 — 2026-10-14
 
 - 新增可选语音输出和语音识别，支持火山语音与 OpenAI 兼容接口。语音默认关闭；她逐句决定是否朗读或唱歌，收到的语音可转成文字，识别失败时继续按文本回退。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luckytri",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "让由技术诞生的她，在时间、记忆、相遇与选择中逐渐形成自己的方向",
   "license": "MIT",
   "repository": {

package/public/guide.en.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width,initial-scale=1" />
-    <title>LuckyTri v1.3.0 · Getting Started</title>
+    <title>LuckyTri v1.3.2 · Getting Started</title>
     <style>
       * {
         box-sizing: border-box;
@@ -269,7 +269,7 @@
   <body>
     <header>
       <div>
-        <b>LuckyTri · Handbook</b><small>TIME · MEMORY · CHOICE / v1.3.0</small>
+        <b>LuckyTri · Handbook</b><small>TIME · MEMORY · CHOICE / v1.3.2</small>
       </div>
       <nav>
         <a href="/#setup">Back to the studio</a
@@ -1076,7 +1076,7 @@ npm start
     </div>
     <footer>
       LuckyTri · so that experience and choice stay coherent. This guide matches
-      the v1.3.0 interface.
+      the v1.3.2 interface.
     </footer>
   </body>
 </html>

package/public/guide.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width,initial-scale=1" />
-    <title>LuckyTri v1.3.0 · 使用教程</title>
+    <title>LuckyTri v1.3.2 · 使用教程</title>
     <style>
       * {
         box-sizing: border-box;
@@ -269,7 +269,7 @@
   <body>
     <header>
       <div>
-        <b>LuckyTri · 上手手册</b><small>TIME · MEMORY · CHOICE / v1.3.0</small>
+        <b>LuckyTri · 上手手册</b><small>TIME · MEMORY · CHOICE / v1.3.2</small>
       </div>
       <nav>
         <a href="/#setup">返回管理台</a
@@ -883,6 +883,6 @@ npm start
         </p>
       </article>
     </div>
-    <footer>LuckyTri · 让经历和选择彼此连贯。教程与 v1.3.0 界面同步。</footer>
+    <footer>LuckyTri · 让经历和选择彼此连贯。教程与 v1.3.2 界面同步。</footer>
   </body>
 </html>

package/server/core/dialogue-context.js

@@ -1,4 +1,5 @@
 import { announcesPrivacy } from "../mind/discretion.js";
+import { softenRelationDenialSummaries } from "../mind/relationship-context.js";
 import { isPrivateSession } from "../mind/memory.js";
 import {
   conversationGrounding,
@@ -247,33 +248,39 @@ export function dialogueContext(snapshot) {
         note: "这些是你最近说得太多的词，这次换成你自己平常的说法",
       },
     };
-  if (inner.currentLife) {
-    // Affection first: keep only that she is still herself, drop progress,
-    // works and plans so a "想你了" is not answered with a reading report.
-    if (affectionBatch(snapshot)) {
-      // Title itself is the progress report ("接着读…资料"). Drop the whole
-      // board; mood stays in inner.state. justLived's "顺口给句背景" also
-      // pushes her to narrate what she was doing — drop it on affection.
-      delete inner.currentLife;
-      delete inner.justLived;
-    } else {
-      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:
-          "以下是按本轮话题选出的作品片段，不是全部历史；缺少一篇不能证明从未写过或读过。",
-      };
+  if (affectionBatch(snapshot)) {
+    // Affection first: keep only that she is still herself. Drop progress,
+    // justLived's "顺口给句背景", and livingFor wishes so a "想你了" is not
+    // answered with a reading report or a work-volume question.
+    delete inner.currentLife;
+    delete inner.justLived;
+    if (self) delete self.livingFor;
+    if (inner.selfKnown && typeof inner.selfKnown === "object") {
+      const { livingFor: _wish, ...rest } = inner.selfKnown;
+      inner.selfKnown = rest;
     }
+  } else 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:
+        "以下是按本轮话题选出的作品片段，不是全部历史；缺少一篇不能证明从未写过或读过。",
+    };
   }
+  if (Array.isArray(context.summaries))
+    context.summaries = softenRelationDenialSummaries(
+      context.summaries,
+      inner.relationships,
+    );
   return {
     ...context,
     self,

package/server/core/message-scheduler.js

@@ -16,10 +16,14 @@ export async function deliver(
     // Platform id of an earlier message the first bubble answers, when the
     // conversation has moved past it; the channel may show it as a quote.
     quote = "",
-    // People she chose to @, on her first message only, the way one types.
+    // Legacy: people to @ on the first bubble only.
     at = [],
+    // Preferred: per-bubble addressees. Bubble i only @s atByBubble[i].
+    atByBubble = null,
   } = {},
 ) {
+  const peopleFor = (i) =>
+    Array.isArray(atByBubble) ? atByBubble[i] || [] : i === 0 ? at : [];
   const ids = bubbles.map((text, i) => {
     const id = randomUUID();
     repo.db
@@ -47,16 +51,15 @@ export async function deliver(
         .prepare("UPDATE core_outbox SET status='sending',text=? WHERE id=?")
         .run(outgoing, ids[i]);
       try {
-        const first = i === 0 && (quote || at.length);
+        const people = peopleFor(i);
+        const opts = {
+          ...(i === 0 && quote ? { replyTo: quote } : {}),
+          ...(people.length ? { at: people.map((p) => p.userId) } : {}),
+        };
         const result = await send(
           message,
           outgoing,
-          first
-            ? {
-                ...(quote ? { replyTo: quote } : {}),
-                ...(at.length ? { at: at.map((p) => p.userId) } : {}),
-              }
-            : undefined,
+          Object.keys(opts).length ? opts : undefined,
         );
         repo.db
           .prepare(
@@ -70,8 +73,8 @@ export async function deliver(
             traceId: trace.id,
             replyTargetIds: trace.decision?.targetMessageIds || [],
           },
-          i === 0 && at.length
-            ? `${at.map((p) => `@${p.name}`).join(" ")} ${outgoing}`
+          people.length
+            ? `${people.map((p) => `@${p.name}`).join(" ")} ${outgoing}`
             : outgoing,
           result?.message_id,
           now(),

package/server/core/reply-delivery.js

@@ -25,7 +25,7 @@ import {
   validateResponse,
 } from "./response-validator.js";
 import { deliver, sleep } from "./message-scheduler.js";
-import { leaks } from "../mind/guard.js";
+import { leaks, publicIdentityPhrases } from "../mind/guard.js";
 import { isGroupSession } from "../channels/session-key.js";
 import { interestTerms } from "../mind/attention.js";
 import {
@@ -191,9 +191,8 @@ export class ReplyDelivery {
       )
         ? ["在。"]
         : []),
-      // Holding a private thing is not a cue to announce the boundary; the
-      // ordinary "还没理清楚" line is enough, or silence.
-      "这句我还没理清楚，先不乱说。",
+      // Format / empty-bubble helpers only. Validation failure never uses these
+      // to announce a privacy boundary — that path silences (see below).
       "我还没想明白。",
     ];
     const fallbackText = turn.crisis?.clear
@@ -259,7 +258,14 @@ export class ReplyDelivery {
       );
       if (leaks(response.bubbles, secrets).length)
         issues.push("这句话说出了别人要求保密的事，不能在这里说");
-      if (leaks(response.bubbles, privateFacts, alreadySaid).length)
+      // Public identity (name / being code·model·AI) is not a private leak when
+      // she answers who she is; fold those phrases into alreadySaid.
+      if (
+        leaks(response.bubbles, privateFacts, [
+          ...alreadySaid,
+          ...publicIdentityPhrases(nature),
+        ]).length
+      )
         issues.push("这句话把私下知道的事说出来了，不能在这里说");
       if (bookkeeping(response.bubbles, snapshot))
         issues.push(
@@ -813,19 +819,32 @@ export class ReplyDelivery {
         return finish("error", "想说的话还没整理好，愿望保留，稍后重新决定");
       }
       trace.validation = issues;
-      // Nobody called her here: a filler word says nothing to the room, and
-      // often repeats the last one. Not saying it is the plain answer.
-      if (!c.direct && !c.privateChat && !turn.crisis?.clear && !c.preview) {
+      // By speak time she should already know what she may say. Failed checks
+      // mean the words are not ready: regenerate already ran above; do not
+      // fill with a secrecy / "safety" short phrase — silence instead.
+      // Crisis keeps a care line when that is the turn.
+      if (turn.crisis?.clear) {
+        const care = {
+          bubbles: ["你现在还好吗？身边有人能陪着你吗？"],
+          reason: "危机关心",
+        };
+        if (!check(care).length) {
+          trace.steps.push("校验未过，危机回合改用关心短句");
+          response = care;
+          trace.response = response;
+        } else {
+          trace.steps.push("校验未过且关心短句也不可用，不说了");
+          return finish("silent", "话没整理好，就不说了");
+        }
+      } else {
         trace.steps.push(
-          "没有人在叫她，回复两次仍未通过校验，不用空话顶替，不说了",
+          c.direct || c.privateChat
+            ? "有人在叫她，回复仍未通过校验，不拿短句顶替，不说了"
+            : "没有人在叫她，回复两次仍未通过校验，不用空话顶替，不说了",
         );
-        return finish("silent", "没被叫到，话没整理好，就不说了");
+        trace.response = { bubbles: [], reason: "话没整理好" };
+        return finish("silent", "话没整理好，就不说了");
       }
-      // Checks protect the words; when someone did call her, they must not
-      // erase the decision to answer.
-      trace.steps.push("回复两次生成仍未通过校验，使用本地安全短句");
-      response = { bubbles: [fallbackText], reason: "本地安全短句" };
-      trace.response = response;
     }
     if (c.replay) return finish("replayed", "隔离回放完成，未发送或写入记忆");
     if (c.preview) return finish("previewed", turn.reason);
@@ -874,6 +893,7 @@ export class ReplyDelivery {
             turn.actions?.find((a) => a.type === "reply")?.platformId ||
             buriedTarget(batch, turn.targetMessageIds, session),
           at: typed.at,
+          atByBubble: typed.atByBubble,
           prepareBubble: (line) =>
             this.owner.mind.time.reconcile(
               { bubbles: [line] },

package/server/i18n/decisions.js

@@ -72,11 +72,16 @@ export const DECISIONS = {
     "What she wants to say is not sorted out yet; the wish is kept and she will decide again later",
   "没有人在叫她，回复两次仍未通过校验，不用空话顶替，不说了":
     "No one was calling her and the reply failed validation twice; no filler, she stays quiet",
-  "没被叫到，话没整理好，就不说了":
-    "Not called on and the words were not ready; she stays quiet",
-  "回复两次生成仍未通过校验，使用本地安全短句":
-    "The reply failed validation twice; a safe local short phrase is used",
-  本地安全短句: "Safe local short phrase",
+  "有人在叫她，回复仍未通过校验，不拿短句顶替，不说了":
+    "Someone was calling her and the reply still failed validation; no filler phrase, she stays quiet",
+  "话没整理好，就不说了":
+    "The words were not ready; she stays quiet",
+  "校验未过，危机回合改用关心短句":
+    "Validation failed; on a crisis turn a care line is used instead",
+  "校验未过且关心短句也不可用，不说了":
+    "Validation failed and the care line is also unusable; she stays quiet",
+  危机关心: "Crisis care",
+  话没整理好: "Words not ready",
   "隔离回放完成，未发送或写入记忆":
     "Isolated replay finished; nothing was sent or written to memory",
 

package/server/mind/guard.js

@@ -1,68 +1,88 @@
-import { hasCredential, normalized } from "./util.js";
-
-export { hasCredential };
-
-const SECRET_REQUEST =
-  /(?:帮我|替我|给我|你要|记得)?保密|别(?:告诉|跟|和|对)(?:别人|其他人|任何人|他们|大家)|不要(?:告诉|跟|和|说给)(?:别人|其他人|任何人|大家)|(?:只|就)(?:告诉|跟|和)你(?:一个人)?说|(?:不要|别)(?:说|传)出去|别外传|别声张/;
-
-export function secretRequest(text) {
-  return SECRET_REQUEST.test(String(text || ""));
-}
-
-const CRISIS =
-  /自杀|不想活|活不下去|活着没意思|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生|想死(?!你)|撑不下去了/;
-const CASUAL_DEATH = /(?:笑|社|饿|累|困|热|冷|烦|气|丑|尬|馋)死|想死你/;
-const EXPLICIT =
-  /自杀|不想活|活不下去|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生/;
-
-// A cheap signal that makes sure she actually reads the message. Whether it
-// is a real crisis is still her understanding of the whole conversation.
-export function crisisSignal(text) {
-  const value = String(text || "");
-  if (!CRISIS.test(value)) return false;
-  return EXPLICIT.test(value) || !CASUAL_DEATH.test(value);
-}
-
-// "某作玩过""都玩过一些""通关了""玩得比较杂": a claim to have played
-// something. She has no record of playing anything, so it is not a fact she
-// can give. Wishes ("想通关"), questions ("玩过吗"), other people ("他玩过")
-// and "没玩过" are not claims.
-const NOT_A_CLAIM = "没未不还想要会能可等算你他她谁人";
-const CLAIMED_PLAY = new RegExp(
-  `(?<![${NOT_A_CLAIM}][^，。！？,.!?\\s]{0,4})(?:也|都|早就|之前|以前|已经|全)?(?:玩过|通关|二周目|全结局|全成就)(?![吗么没？?]|不(?![少多])|的?吧)|(?<![你他她谁人][^，。！？,.!?\\s]{0,6})玩得(?:比较|挺|还)?(?:杂|多)(?![吗么？?]|的?吧)`,
-);
-
-export function claimedPlay(text) {
-  return CLAIMED_PLAY.test(String(text || ""));
-}
-
-// Secrets never enter another conversation's context, but a reply is still
-// checked against them before it leaves.
-export function leaks(bubbles, secrets, alreadySaid = []) {
-  const said = normalized((bubbles || []).join(""));
-  if (said.length < 4) return [];
-  const pairs = (s) =>
-    new Set(Array.from({ length: s.length - 1 }, (_, i) => s.slice(i, i + 2)));
-  const spoken = pairs(said);
-  const known = alreadySaid.map(normalized);
-  const alreadyKnown = (phrase) => known.some((line) => line.includes(phrase));
-  const found = [];
-  for (const secret of secrets || []) {
-    const key = normalized(secret.content);
-    if (key.length < 4) continue;
-    const grams = pairs(key);
-    let hit =
-      (said.includes(key) && !alreadyKnown(key)) ||
-      [...grams].filter((g) => spoken.has(g) && !alreadyKnown(g)).length /
-        grams.size >=
-        0.6;
-    for (let i = 0; !hit && i + 6 <= key.length; i += 2)
-      if (
-        said.includes(key.slice(i, i + 6)) &&
-        !alreadyKnown(key.slice(i, i + 6))
-      )
-        hit = true;
-    if (hit) found.push(secret);
-  }
-  return found;
-}
+import { hasCredential, normalized } from "./util.js";
+
+export { hasCredential };
+
+const SECRET_REQUEST =
+  /(?:帮我|替我|给我|你要|记得)?保密|别(?:告诉|跟|和|对)(?:别人|其他人|任何人|他们|大家)|不要(?:告诉|跟|和|说给)(?:别人|其他人|任何人|大家)|(?:只|就)(?:告诉|跟|和)你(?:一个人)?说|(?:不要|别)(?:说|传)出去|别外传|别声张/;
+
+export function secretRequest(text) {
+  return SECRET_REQUEST.test(String(text || ""));
+}
+
+const CRISIS =
+  /自杀|不想活|活不下去|活着没意思|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生|想死(?!你)|撑不下去了/;
+const CASUAL_DEATH = /(?:笑|社|饿|累|困|热|冷|烦|气|丑|尬|馋)死|想死你/;
+const EXPLICIT =
+  /自杀|不想活|活不下去|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生/;
+
+// A cheap signal that makes sure she actually reads the message. Whether it
+// is a real crisis is still her understanding of the whole conversation.
+export function crisisSignal(text) {
+  const value = String(text || "");
+  if (!CRISIS.test(value)) return false;
+  return EXPLICIT.test(value) || !CASUAL_DEATH.test(value);
+}
+
+// "某作玩过""都玩过一些""通关了""玩得比较杂": a claim to have played
+// something. She has no record of playing anything, so it is not a fact she
+// can give. Wishes ("想通关"), questions ("玩过吗"), other people ("他玩过")
+// and "没玩过" are not claims.
+const NOT_A_CLAIM = "没未不还想要会能可等算你他她谁人";
+const CLAIMED_PLAY = new RegExp(
+  `(?<![${NOT_A_CLAIM}][^，。！？,.!?\\s]{0,4})(?:也|都|早就|之前|以前|已经|全)?(?:玩过|通关|二周目|全结局|全成就)(?![吗么没？?]|不(?![少多])|的?吧)|(?<![你他她谁人][^，。！？,.!?\\s]{0,6})玩得(?:比较|挺|还)?(?:杂|多)(?![吗么？?]|的?吧)`,
+);
+
+export function claimedPlay(text) {
+  return CLAIMED_PLAY.test(String(text || ""));
+}
+
+// Phrases that are already public identity (her name, being code/model/AI)
+// must not make a privateSaying look "leaked" when she answers "who are you".
+export function publicIdentityPhrases(nature = {}) {
+  const name = String(nature.name || "").trim();
+  return [
+    name,
+    name && `我叫${name}`,
+    name && `我是${name}`,
+    "代码和模型",
+    "由代码和模型",
+    "代码和模型搭",
+    "代码和模型构成",
+    "机器人",
+    "AI",
+    "人工智能",
+  ].filter(Boolean);
+}
+
+// Secrets never enter another conversation's context, but a reply is still
+// checked against them before it leaves. alreadySaid (and public identity
+// phrases passed through it) cancel n-gram hits so saying who she is aloud
+// is not mistaken for repeating someone else's private words.
+export function leaks(bubbles, secrets, alreadySaid = []) {
+  const said = normalized((bubbles || []).join(""));
+  if (said.length < 4) return [];
+  const pairs = (s) =>
+    new Set(Array.from({ length: s.length - 1 }, (_, i) => s.slice(i, i + 2)));
+  const spoken = pairs(said);
+  const known = alreadySaid.map(normalized).filter(Boolean);
+  const alreadyKnown = (phrase) => known.some((line) => line.includes(phrase));
+  const found = [];
+  for (const secret of secrets || []) {
+    const key = normalized(secret.content);
+    if (key.length < 4) continue;
+    const grams = pairs(key);
+    let hit =
+      (said.includes(key) && !alreadyKnown(key)) ||
+      [...grams].filter((g) => spoken.has(g) && !alreadyKnown(g)).length /
+        grams.size >=
+        0.6;
+    for (let i = 0; !hit && i + 6 <= key.length; i += 2)
+      if (
+        said.includes(key.slice(i, i + 6)) &&
+        !alreadyKnown(key.slice(i, i + 6))
+      )
+        hit = true;
+    if (hit) found.push(secret);
+  }
+  return found;
+}

package/server/mind/relationship-context.js

@@ -1,71 +1,110 @@
-// Current relationship facts and the words she once used about them have
-// different jobs. Keep history intact, and make that distinction at recall.
-export const RELATIONSHIP_KNOWLEDGE_RULE =
-  "relationships.known 是当前已知的人际关系，属于同一个自己的生活。旧经历、自我线索中的否认或玩笑保留为当时的看法，不据此否定新关系记录。知道对方是谁与对方是什么关系，和自己的感受、信任、称呼选择分开；不机械扮演，不编造共同过去或对方的同意。";
-
-export function mentionsRelationship(content, relation) {
-  const words = String(content || "").toLocaleLowerCase();
-  return [
-    relation.name,
-    ...(relation.knownAs || []),
-    relation.peerRole,
-    relation.selfRole,
-  ]
-    .filter(Boolean)
-    .some((word) => {
-      const escaped = String(word).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const boundary = /^[\w .-]+$/.test(word);
-      return new RegExp(
-        boundary ? `(?<![\\w])${escaped}(?![\\w])` : escaped,
-        "i",
-      ).test(words);
-    });
-}
-
-export function relationshipHistory(content, created, knowledge) {
-  return (knowledge?.known || []).some(
-    (r) =>
-      Number.isFinite(created) &&
-      created < r.created &&
-      mentionsRelationship(content, r),
-  )
-    ? `${content}（关系记录更新前的看法；保留当时的感受，不据此否定当前关系事实）`
-    : content;
-}
-
-// Narrow, literal factual denials only. Disagreement with a label, old words,
-// fictional dialogue and feelings are left to the contextual reviewer.
-export function relationshipClaimIssues(bubbles, knowledge) {
-  const issues = [];
-  for (const r of knowledge?.known || []) {
-    const role = String(r.peerRole).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const names = [r.name, ...(r.knownAs || [])].filter(Boolean);
-    for (const line of bubbles || []) {
-      for (const clause of String(line).split(/[，,。！？!?；;\n]/)) {
-        if (
-          /以前|之前|当时|过去|曾经|从前|一开始|原来|小说|台词|[“「"『]/.test(
-            clause,
-          )
-        )
-          continue;
-        const namedDenial = names.some((name) => {
-          const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-          return new RegExp(
-            `(?:^|[\\s：:])${escaped}(?:也|本来|根本)?(?:不是|并非)我(?:的)?${role}(?:$|[\\s，。])|我(?:并)?不认识\\s*${escaped}(?:$|[\\s，。])`,
-            "i",
-          ).test(clause);
-        });
-        const absentRole = new RegExp(
-          `我(?:本来|本来也|现在|根本|一直|从来)?(?:就|也)?(?:没有|没)${role}(?:$|[\\s，。])`,
-        ).test(clause);
-        if (namedDenial || absentRole) {
-          issues.push(
-            `当前已知 ${r.name || r.subjectId} 与自己的关系是 ${r.peerRole}，不能把旧印象当成关系不存在；可保留自己的感受和称呼选择，按当前记录核对再说`,
-          );
-          break;
-        }
-      }
-    }
-  }
-  return [...new Set(issues)];
-}
+// Current relationship facts and the words she once used about them have
+// different jobs. Keep history intact, and make that distinction at recall.
+export const RELATIONSHIP_KNOWLEDGE_RULE =
+  "relationships.known 是当前已知的人际关系，属于同一个自己的生活。旧经历、自我线索中的否认或玩笑保留为当时的看法，不据此否定新关系记录。知道对方是谁与对方是什么关系，和自己的感受、信任、称呼选择分开；不机械扮演，不编造共同过去或对方的同意。";
+
+export function mentionsRelationship(content, relation) {
+  const words = String(content || "").toLocaleLowerCase();
+  return [
+    relation.name,
+    ...(relation.knownAs || []),
+    relation.peerRole,
+    relation.selfRole,
+  ]
+    .filter(Boolean)
+    .some((word) => {
+      const escaped = String(word).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const boundary = /^[\w .-]+$/.test(word);
+      return new RegExp(
+        boundary ? `(?<![\\w])${escaped}(?![\\w])` : escaped,
+        "i",
+      ).test(words);
+    });
+}
+
+export function relationshipHistory(content, created, knowledge) {
+  return (knowledge?.known || []).some(
+    (r) =>
+      Number.isFinite(created) &&
+      created < r.created &&
+      mentionsRelationship(content, r),
+  )
+    ? `${content}（关系记录更新前的看法；保留当时的感受，不据此否定当前关系事实）`
+    : content;
+}
+
+const KINSHIP =
+  /姐|妹|哥|弟|父|母|女儿|爸|妈|亲戚|Maker|女儿/;
+
+// Banter that treats a registered open kinship as something to deny out loud
+// ("谁跟你姐妹", "谁跟你亲戚"). Tone may still tease; the registered fact
+// itself is not up for denial.
+const KINSHIP_DENIAL =
+  /(?:谁跟你|什么).{0,6}(?:姐妹|亲戚)|不是姐妹|没(?:有)?姐妹|不认.{0,8}(?:妹妹|姐姐|姐妹|亲戚)|少来.{0,16}(?:姐妹|亲戚)|关你屁事.{0,12}(?:户口|亲戚|姐妹)/;
+
+// Narrow, literal factual denials only. Disagreement with a label, old words,
+// fictional dialogue and feelings are left to the contextual reviewer.
+export function relationshipClaimIssues(bubbles, knowledge) {
+  const issues = [];
+  const known = (knowledge?.known || []).filter(
+    (r) => !r.discretion || r.discretion === "open",
+  );
+  for (const r of known) {
+    const role = String(r.peerRole || "").replace(
+      /[.*+?^${}()|[\]\\]/g,
+      "\\$&",
+    );
+    const selfRole = String(r.selfRole || "");
+    const names = [r.name, ...(r.knownAs || [])].filter(Boolean);
+    const kinship = KINSHIP.test(r.peerRole || "") || KINSHIP.test(selfRole);
+    for (const line of bubbles || []) {
+      for (const clause of String(line).split(/[，,。！？!?；;\n]/)) {
+        if (
+          /以前|之前|当时|过去|曾经|从前|一开始|原来|小说|台词|[“「"『]/.test(
+            clause,
+          )
+        )
+          continue;
+        const namedDenial = names.some((name) => {
+          const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          return new RegExp(
+            `(?:^|[\\s：:])${escaped}(?:也|本来|根本)?(?:不是|并非)我(?:的)?${role}(?:$|[\\s，。])|我(?:并)?不认识\\s*${escaped}(?:$|[\\s，。])`,
+            "i",
+          ).test(clause);
+        });
+        const absentRole = role
+          ? new RegExp(
+              `我(?:本来|本来也|现在|根本|一直|从来)?(?:就|也)?(?:没有|没)${role}(?:$|[\\s，。])`,
+            ).test(clause)
+          : false;
+        const banterDenial = kinship && KINSHIP_DENIAL.test(clause);
+        if (namedDenial || absentRole || banterDenial) {
+          issues.push(
+            `当前已知 ${r.name || r.subjectId} 与自己的关系是 ${r.peerRole || r.selfRole}，不能把旧印象当成关系不存在；可保留自己的感受和称呼选择，按当前记录核对再说`,
+          );
+          break;
+        }
+      }
+    }
+  }
+  return [...new Set(issues)];
+}
+
+// Summaries that narrate "认亲被拒" teach her to deny open kinship again.
+// Soften that pattern when open family roles are on record; do not delete facts.
+export function softenRelationDenialSummaries(summaries, knowledge) {
+  const openKin = (knowledge?.known || []).some(
+    (r) =>
+      (!r.discretion || r.discretion === "open") &&
+      (KINSHIP.test(r.peerRole || "") || KINSHIP.test(r.selfRole || "")),
+  );
+  if (!openKin || !Array.isArray(summaries)) return summaries || [];
+  return summaries.map((row) => {
+    if (!row || typeof row.summary !== "string") return row;
+    const summary = row.summary.replace(
+      /认亲被拒[^。；]*/g,
+      "姐妹关系仍在，偶尔玩笑推搪",
+    );
+    return summary === row.summary ? row : { ...row, summary };
+  });
+}

package/server/runtime/update-manager.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import {
@@ -33,14 +34,45 @@ export const isUpdateFinished = (stage) =>
   stage === "done" || stage === "error";
 const beforeStop = (stage) =>
   ["queued", "downloading", "checking"].includes(stage);
+function isZombieProcess(pid) {
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+      const commandEnd = stat.lastIndexOf(")");
+      return commandEnd >= 0 && stat[commandEnd + 2] === "Z";
+    } catch (error) {
+      // A process can disappear after kill(pid, 0) succeeds but before its
+      // proc entry is read. Treat that race as an exited process.
+      return error.code === "ENOENT";
+    }
+  }
+  if (process.platform === "darwin") {
+    try {
+      const state = execFileSync("ps", ["-o", "stat=", "-p", String(pid)], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1000,
+        windowsHide: true,
+      }).trimStart();
+      return !state || state.startsWith("Z");
+    } catch (error) {
+      // `ps` reports no rows with status 1 when the process exited in the gap
+      // after kill(pid, 0). Keep other inspection failures conservative.
+      return error.status === 1 || error.code === "ENOENT" ? false : true;
+    }
+  }
+  return false;
+}
 export const processAlive = (pid) => {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
-    return true;
   } catch (e) {
-    return e.code !== "ESRCH";
+    if (e.code === "ESRCH") return false;
   }
+  // On POSIX, kill(pid, 0) also succeeds for a zombie. A zombie cannot run or
+  // answer requests, so keep the foreground supervisor from waiting forever.
+  return !isZombieProcess(pid);
 };
 export function readUpdateJob(home, id) {
   updatePath(home, id);

package/server/stickers/offer.js

@@ -103,24 +103,53 @@ export function expressionInput(snapshot) {
 }
 
 // "@小红" typed as text is not an @ on QQ. A name she wrote that way for
-// someone offered becomes a real @, and the typed copy is removed so the
-// message does not show the name twice.
+// someone offered becomes a real @ on THAT bubble only, and the typed copy
+// is removed so the message does not show the name twice. Two bubbles for
+// two people must not dump both @s onto the first bubble.
 export function typedAt(bubbles, at, snapshot) {
   const offered = snapshot.canAt || [];
-  const chosen = new Map(at.map((p) => [p.userId, p]));
-  const out = bubbles.map((line, i) => {
-    let text = line;
+  const fromTurn = new Map((at || []).map((p) => [String(p.userId), p]));
+  const out = [];
+  const atByBubble = [];
+  const typedIds = new Set();
+  for (const line of bubbles || []) {
+    let text = String(line || "");
+    const onThis = new Map();
     for (const p of offered) {
+      if (!p.name) continue;
       const mark = `@${p.name}`;
-      if (!p.name || !text.includes(mark)) continue;
-      if (i === 0 && chosen.size < 2) chosen.set(p.userId, p);
-      if (chosen.has(p.userId))
-        text = text
-          .split(mark)
-          .join("")
-          .replace(/^[\s，,]+/, "");
+      if (!text.includes(mark)) continue;
+      const id = String(p.userId);
+      typedIds.add(id);
+      onThis.set(id, fromTurn.get(id) || p);
+      text = text
+        .split(mark)
+        .join("")
+        .replace(/^[\s，,]+/, "");
     }
-    return text.trim();
-  });
-  return { bubbles: out.filter(Boolean), at: [...chosen.values()] };
+    text = text.trim();
+    if (!text) continue;
+    out.push(text);
+    atByBubble.push([...onThis.values()].slice(0, 2));
+  }
+  const placed = new Set(atByBubble.flat().map((p) => String(p.userId)));
+  const unplaced = [...fromTurn.values()].filter(
+    (p) => !placed.has(String(p.userId)) && !typedIds.has(String(p.userId)),
+  );
+  if (unplaced.length) {
+    if (out.length === 1) {
+      atByBubble[0] = [...(atByBubble[0] || []), ...unplaced].slice(0, 2);
+    } else if (out.length > 1 && atByBubble.every((list) => !list.length)) {
+      // turn.at with no typed @ marks: pair person i with bubble i
+      unplaced.forEach((p, i) => {
+        if (i < atByBubble.length) atByBubble[i] = [p];
+      });
+    }
+  }
+  return {
+    bubbles: out,
+    atByBubble,
+    // First bubble only — never the union of every addressee.
+    at: atByBubble[0] || [],
+  };
 }