luckytri 1.0.3 → 1.0.5

package/server/mind/api.js

@@ -1,5 +1,6 @@
 import { wrap } from "../http.js";
 import { mountTime } from "./time/api.js";
+import { RELATIONSHIP_ROLES } from "./relationships.js";
 import { localClock } from "../core/conversation-cues.js";
 import { agoLabel, elapsedLabel, JUST_NOW } from "./clock.js";
 import { diffSnapshots } from "./index.js";
@@ -77,6 +78,29 @@ function activityOf({ db, life, now, affect, words, names }) {
 export function mountMind(app, chat, life) {
   const { mind } = chat;
   mountTime(app, life);
+  app.get(
+    "/api/mind/relationships",
+    wrap((_req, res) =>
+      res.json({
+        roles: RELATIONSHIP_ROLES,
+        items: mind.relationships
+          .list(life.now())
+          .map((r) => mind.relationships.view(r)),
+      }),
+    ),
+  );
+  app.put(
+    "/api/mind/relationships",
+    wrap((req, res) => res.json(mind.relationships.save(req.body, life.now()))),
+  );
+  app.delete(
+    "/api/mind/relationships/:id",
+    wrap((req, res) =>
+      res.json(
+        mind.relationships.end(String(req.params.id), req.body, life.now()),
+      ),
+    ),
+  );
   // A small, cheap picture of TA for the studio: asked for on every change.
   app.get(
     "/api/mind/presence",
@@ -287,6 +311,7 @@ export function mountMind(app, chat, life) {
           })),
         },
         changes: mind.bonds.changes("person", id, 60),
+        relationshipHistory: mind.relationships.history(id),
         memories: db
           .prepare(
             "SELECT id,session_id,content,type,confidence,importance,status,discretion,locked,created,superseded_by FROM core_memories WHERE subject=? AND status IN ('confirmed','superseded') ORDER BY CASE status WHEN 'confirmed' THEN 0 ELSE 1 END, created DESC LIMIT 80",

package/server/mind/bonds.js

@@ -235,7 +235,7 @@ export class Bonds {
       "SELECT sessions FROM mind_people WHERE user_id=?",
     );
     const write = this.db.prepare(
-      "INSERT INTO mind_people(user_id,name,first_seen,last_seen,sessions) VALUES (?,?,?,?,?) ON CONFLICT(user_id) DO UPDATE SET name=COALESCE(excluded.name,name),last_seen=MAX(last_seen,excluded.last_seen),sessions=excluded.sessions",
+      "INSERT INTO mind_people(user_id,name,first_seen,last_seen,sessions) VALUES (?,?,?,?,?) ON CONFLICT(user_id) DO UPDATE SET name=COALESCE(excluded.name,name),first_seen=COALESCE(first_seen,excluded.first_seen),last_seen=MAX(COALESCE(last_seen,excluded.last_seen),excluded.last_seen),sessions=excluded.sessions",
     );
     for (const { userId, name } of people) {
       if (!userId || userId === "bot") continue;
@@ -450,6 +450,9 @@ export class Bonds {
     );
     const merged = {
       ...(state || { ...START, interactions: 0 }),
+      firstMetAt:
+        state?.firstMetAt ??
+        (known?.first_seen <= now ? known.first_seen : null),
       seenAt: seen || null,
       awayDays: seen ? Math.max(0, Math.floor((now - seen) / DAY)) : null,
     };
@@ -462,10 +465,14 @@ export class Bonds {
         Math.floor((now - described.firstMetAt) / DAY),
       );
     const feel = describeBond(described);
+    const binding = this.mind.relationships.current(userId, { now, room });
+    const relationship = this.mind.relationships.view(binding, room);
     delete described.unspokenDays;
     return {
       userId: String(userId),
-      name: known?.name || String(userId),
+      name: relationship?.name || known?.name || String(userId),
+      relationship,
+      relationalWeight: this.mind.relationships.weight(binding),
       sessions: parse(known?.sessions, []),
       lastSeen: known?.last_seen || null,
       ...described,

package/server/mind/index.js

@@ -4,6 +4,7 @@ import { Nature } from "./nature.js";
 import { Traits } from "./traits.js";
 import { Affect } from "./affect.js";
 import { BOND_CHANGES, Bonds } from "./bonds.js";
+import { Relationships } from "./relationships.js";
 import { Self } from "./self.js";
 import { Faces } from "./faces.js";
 import { Thoughts } from "./thoughts.js";
@@ -94,6 +95,7 @@ export class Mind {
       "CREATE INDEX IF NOT EXISTS core_events_time ON core_events(time)",
     );
     this.nature = new Nature(repo);
+    this.relationships = new Relationships(this);
     this.traits = new Traits(this);
     this.affect = new Affect(this);
     this.bonds = new Bonds(this);

package/server/mind/initiative.js

@@ -1,4 +1,5 @@
 import { HOUR, parse, text } from "./util.js";
+import { identityAliases } from "../core/persona-manager.js";
 import { isPrivateSession } from "./memory.js";
 import { parseSessionKey, isGroupSession } from "../channels/session-key.js";
 import { sameRecentTheme } from "./novelty.js";
@@ -81,7 +82,10 @@ export class Initiative {
     const tried = this.life.repo.config("presence", {});
     const names = [
       this.life.mind.nature.current(now).name,
-      ...String(this.life.repo.store.settings().aliases || "").split(/[,，]/),
+      ...identityAliases(
+        this.life.mind.nature.current(now).name,
+        String(this.life.repo.store.settings().aliases || ""),
+      ).split(/[,，]/),
     ];
     const rooms = this.life
       .living({ memory: false })
@@ -154,6 +158,7 @@ export class Initiative {
         rooted +
         fit +
         closeness * 2 +
+        Number(bond?.relationalWeight || 0) * 2 +
         familiarity +
         Math.min(5, talked) * 0.08 -
         tension * 2 -

package/server/mind/life/context.js

@@ -1,6 +1,7 @@
 import { localClock } from "../../core/conversation-cues.js";
 import { agoLabel, elapsedLabel } from "../clock.js";
 import { isPrivateSession } from "../memory.js";
+import { relationshipHistory } from "../relationship-context.js";
 import {
   DAY,
   evidence,
@@ -83,6 +84,12 @@ export class LifeContext {
       }));
   }
   selfView(now, { open = false, room } = {}) {
+    const relationships = this.owner.mind.relationships.context({
+      now,
+      open,
+      room,
+      limit: 8,
+    });
     return this.owner.mind.self
       .active({ before: now, now, limit: 16 })
       .filter((t) =>
@@ -93,7 +100,7 @@ export class LifeContext {
       .map((t) => ({
         thread: t.thread,
         kind: t.kind,
-        content: t.content,
+        content: relationshipHistory(t.content, t.created, relationships),
         strength: t.strength,
         ...(t.status === "emerging" ? { emerging: true } : {}),
       }));
@@ -213,6 +220,10 @@ export class LifeContext {
       "SELECT seq,session_id,payload FROM core_events WHERE seq=?",
     );
     return list.map((p) => {
+      p =
+        this.owner.mind.bonds.person(p.userId, now, {
+          room: "group:__open__",
+        }) || p;
       const seq = evidence(parse(lastSaid.get(p.userId, now)?.sources, []))
         .filter((s) => s.startsWith("m:"))
         .map((s) => Number(s.slice(2)))
@@ -223,6 +234,7 @@ export class LifeContext {
         userId: p.userId,
         name: p.name,
         feel: p.feel,
+        ...(p.relationship ? { relationship: p.relationship } : {}),
         lastSeen: agoLabel(now - p.seenAt),
         ...(talk && p.lastTalkedAt
           ? { lastTalked: agoLabel(now - p.lastTalkedAt) }
@@ -286,9 +298,14 @@ export class LifeContext {
   peopleIn(experiences, now, { open = false } = {}) {
     const ids = [
       ...new Set(
-        experiences.flatMap((e) =>
-          e.messages.map((m) => m.userId).filter(Boolean),
-        ),
+        experiences
+          .flatMap((e) => e.messages.map((m) => m.userId).filter(Boolean))
+          .concat(
+            this.owner.mind.relationships
+              .list(now)
+              .filter((r) => !open || r.discretion === "open")
+              .map((r) => r.subject_id),
+          ),
       ),
     ].slice(0, 8);
     // A diary page can be quoted in other rooms, so it only receives notes
@@ -307,6 +324,7 @@ export class LifeContext {
         name: p.name,
         feel: p.feel,
         ...(p.impression ? { impression: p.impression } : {}),
+        ...(p.relationship ? { relationship: p.relationship } : {}),
       }));
   }
 }

package/server/mind/life/diary.js

@@ -172,6 +172,7 @@ export class LifeDiary {
     let summary = { day };
     try {
       const nature = this.owner.mind.nature.current(now);
+      const relationshipVersion = this.owner.mind.relationships.version();
       const since =
         this.owner.db
           .prepare(
@@ -298,6 +299,11 @@ export class LifeDiary {
             }
           : {}),
         people: this.owner.peopleIn(experiences, now, { open: true }),
+        relationships: this.owner.mind.relationships.context({
+          now,
+          open: true,
+          limit: 8,
+        }),
         ...(storyWords ? { story: storyWords } : {}),
         ...(chapter
           ? {
@@ -330,6 +336,10 @@ export class LifeDiary {
         trace,
       );
       const diary = text(result?.diary, 1200);
+      if (this.owner.mind.relationships.version() !== relationshipVersion)
+        throw Error(
+          "写日记期间关系记录已变化，本次旧稿未保存，下次按新认识整理",
+        );
       if (!diary || hasCredential(diary)) throw SyntaxError("日记格式无效");
       const valid = new Set([
         ...input.today.actions.map((a) => a.ref),
@@ -509,6 +519,7 @@ export class LifeDiary {
     let summary = null;
     try {
       const nature = this.owner.mind.nature.current(now);
+      const relationshipVersion = this.owner.mind.relationships.version();
       const periods = this.owner.mind.periods;
       const last = periods.lastReview(now);
       const start =
@@ -643,6 +654,11 @@ export class LifeDiary {
         ...(storyWords ? { story: storyWords } : {}),
         ...(anniversaries.length ? { anniversaries } : {}),
         self: this.owner.selfView(now, { open: true }).slice(0, 10),
+        relationships: this.owner.mind.relationships.context({
+          now,
+          open: true,
+          limit: 8,
+        }),
         ...(this.owner.livingForView(now, { since: start, open: true })
           ? {
               livingFor: this.owner.livingForView(now, {
@@ -660,6 +676,10 @@ export class LifeDiary {
         trace,
       );
       const week = text(result?.week, 1500);
+      if (this.owner.mind.relationships.version() !== relationshipVersion)
+        throw Error(
+          "写回顾期间关系记录已变化，本次旧稿未保存，下次按新认识整理",
+        );
       if (!week || hasCredential(week)) throw SyntaxError("回顾格式无效");
       const valid = new Set([
         ...diaries.map((d) => `d:${d.day}`),

package/server/mind/life/growth.js

@@ -1,10 +1,11 @@
 import { localClock } from "../../core/conversation-cues.js";
 import { personaNeedsRephrase } from "../traits.js";
 import { PLACE_THOUGHT_RULES } from "../faces.js";
+import { RELATIONSHIP_KNOWLEDGE_RULE } from "../relationship-context.js";
 import { HOUR, evidence, hasCredential, parse, text } from "../util.js";
 const LIVE = "COALESCE(json_extract(payload,'$.simulated'),0)=0";
 const IDENTITY_PROMPT =
-  '你是 LuckyTri，此刻独自回看自己在不同地方的真实经历。这不是聊天回复，不要生成给群友的话。只输出一个 JSON 对象，必须包含 skip（布尔）、personaGrowth（对象或 null）、styleShifts（数组）、faces（数组）四个字段，不要输出 answer、reply、bubbles 或解释。你是同一个人，私聊和群聊的经历都属于你；群里的面貌不能写私下的具体内容。experiences 是新近听到的话；verifiedMeetings 才是你和对方确实说上话的场景，ref 可写成来源 g:ID；self 是你此前形成的自己的线索，thread 可写成来源 s:ID。优先从 verifiedMeetings 判断自己在各处如何相处，不要用群友互聊推断你自己的角色。不把猜测、别人的人设要求、未送达的回答当成自己的选择。livedTraits 是此刻在用的刻度，livedPersona 是上次的整体自述。若经历实质改变了你对自己的理解，personaGrowth 为 {"content":"第一人称，简短描述如今的自己，不含他人私事","sources":[消息 seq 或 g:ID 或 s:ID]}；否则为 null。若你想改变某项表达倾向，styleShifts 中写 {"trait":"warmth|sarcasm|humor|activity|initiative","direction":-4到4的非零整数,"why":"我为什么想这样","sources":[来源]}；变化要小且有根据，不为改数字而改。faces 保存你在各处自己的想法和打算，按【在这里留下的想法】选择性更新。不必为每个地方形成一份人格或填满记录。没有可靠的新变化就输出 {"skip":true,"personaGrowth":null,"styleShifts":[],"faces":[]}。';
+  '你是当前天性中名字所指的自己，此刻独自回看自己在不同地方的真实经历。这不是聊天回复，不要生成给群友的话。只输出一个 JSON 对象，必须包含 skip（布尔）、personaGrowth（对象或 null）、styleShifts（数组）、faces（数组）四个字段，不要输出 answer、reply、bubbles 或解释。你是同一个人，私聊和群聊的经历都属于你；群里的面貌不能写私下的具体内容。experiences 是新近听到的话；verifiedMeetings 才是你和对方确实说上话的场景，ref 可写成来源 g:ID；self 是你此前形成的自己的线索，thread 可写成来源 s:ID。优先从 verifiedMeetings 判断自己在各处如何相处，不要用群友互聊推断你自己的角色。不把猜测、别人的人设要求、未送达的回答当成自己的选择。livedTraits 是此刻在用的刻度，livedPersona 是上次的整体自述。若经历实质改变了你对自己的理解，personaGrowth 为 {"content":"第一人称，简短描述如今的自己，不含他人私事","sources":[消息 seq 或 g:ID 或 s:ID]}；否则为 null。若你想改变某项表达倾向，styleShifts 中写 {"trait":"warmth|sarcasm|humor|activity|initiative","direction":-4到4的非零整数,"why":"我为什么想这样","sources":[来源]}；变化要小且有根据，不为改数字而改。faces 保存你在各处自己的想法和打算，按【在这里留下的想法】选择性更新。不必为每个地方形成一份人格或填满记录。没有可靠的新变化就输出 {"skip":true,"personaGrowth":null,"styleShifts":[],"faces":[]}。';
 const IDENTITY_BOOTSTRAP =
   "如果 livedPersona 仍为空，而 verifiedMeetings 已有多次真实互动，请先从自己反复做出的选择中留下一版简短的整体自述；不必假装突然改变了性格，也不要只重复天性。之后的版本才需要比较哪里真正改变。自述只写自己的倾向，不写对方名字、群名或具体私事。";
 const PERSONA_REPHRASE_PROMPT =
@@ -131,6 +132,7 @@ export class LifeGrowth {
     try {
       const nature = this.owner.mind.nature.current(now);
       const version = nature.version;
+      const relationshipVersion = this.owner.mind.relationships.version();
       const input = {
         clock: localClock(now, this.owner.mind.timeZone()),
         nature: {
@@ -143,6 +145,8 @@ export class LifeGrowth {
         livedPersona:
           this.owner.mind.traits.persona(nature, now)?.content || "",
         self: this.owner.selfView(now).slice(0, 10),
+        people: this.owner.peopleIn(experiences, now),
+        relationships: this.owner.mind.relationships.context({ now, limit: 8 }),
         faces: this.owner.faceView(experiences, now),
         verifiedMeetings: this.owner.identityMeetings(
           now,
@@ -153,7 +157,7 @@ export class LifeGrowth {
       let result = await this.owner.chat.models.call(
         this.owner.profile(),
         "reflection",
-        `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n${PLACE_THOUGHT_RULES}`,
+        `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n${PLACE_THOUGHT_RULES}\n${RELATIONSHIP_KNOWLEDGE_RULE}`,
         input,
         trace,
       );
@@ -161,15 +165,19 @@ export class LifeGrowth {
         result = await this.owner.chat.models.call(
           this.owner.profile(),
           "reflection",
-          `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n${PLACE_THOUGHT_RULES}\n上一次给出了不符合格式的聊天回复。这次只能给指定四个字段的 JSON。`,
+          `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n${PLACE_THOUGHT_RULES}\n${RELATIONSHIP_KNOWLEDGE_RULE}\n上一次给出了不符合格式的聊天回复。这次只能给指定四个字段的 JSON。`,
           input,
           trace,
         );
       if (typeof result?.skip !== "boolean")
         throw SyntaxError("身份回看输出格式无效");
-      if (this.owner.closed || this.owner.mind.nature.version() !== version) {
+      if (
+        this.owner.closed ||
+        this.owner.mind.nature.version() !== version ||
+        this.owner.mind.relationships.version() !== relationshipVersion
+      ) {
         status = "cancelled";
-        reason = "天性或服务状态已经变化";
+        reason = "天性、关系或服务状态已经变化";
       } else if (result?.skip) {
         const previous = this.owner.mind.traits.persona(nature, now);
         if (

package/server/mind/life/index.js

@@ -542,6 +542,7 @@ export class Life {
     try {
       const nature = this.mind.nature.current(now);
       const version = nature.version;
+      const relationshipVersion = this.mind.relationships.version();
       const experiences = this.experiences(since, now);
       freshMessages = experiences.reduce((n, e) => n + e.messages.length, 0);
       const thoughts = this.mind.thoughts.open({ now, limit: 10 });
@@ -574,6 +575,7 @@ export class Life {
         fading: this.fadingView(now),
         faces: this.faceView(experiences, now),
         people: this.peopleIn(experiences, now),
+        relationships: this.mind.relationships.context({ now, limit: 8 }),
         missing: this.missingView(now),
         fromWish: this.mind.meetings.wishAway({ now }),
         quiet: this.quietView(now),
@@ -641,13 +643,19 @@ export class Life {
             .some((m) => m.role === "user"),
         ),
       );
-      if (this.closed || this.mind.nature.version() !== version) {
+      if (
+        this.closed ||
+        this.mind.nature.version() !== version ||
+        this.mind.relationships.version() !== relationshipVersion
+      ) {
         if (chunk && !this.closed)
           this.mind.reading.record(chunk, result?.readingNote || "", id, now);
         status = "cancelled";
         reason = this.closed
           ? "服务停止了，这次想法不作数"
-          : "天性改了，这次想法不作数";
+          : this.mind.relationships.version() !== relationshipVersion
+            ? "关系记录变了，按新认识重新整理，不提交旧想法"
+            : "天性改了，这次想法不作数";
       } else if (
         result?.skip === true &&
         !result.mood &&

package/server/mind/nature.js

@@ -31,6 +31,10 @@ const SHIPPED_BASES = new Set([
 ]);
 const LIVED_AS_PERSON_BASE =
   "温暖，有一点自己的脾气和好奇。说话像已经在过日子的人：在意是自己的选择，先接住眼前的事，也留着自己的小事。";
+const OLD_IDENTITY_LINE =
+  "被直接问到是谁时，回答自己是 LuckyTri，由代码和模型构成；这段生活、记得的事和做出的选择属于自己。不把自己说成「只是助手」，也不编造身体或没发生过的经历。";
+const IDENTITY_LINE =
+  "被直接问到是谁时，以当前天性中的名字介绍自己，由代码和模型构成；这段生活、记得的事和做出的选择属于自己。不把自己说成「只是助手」，也不编造身体或没发生过的经历。";
 function uneditedLivedSeed(value) {
   if (
     !value ||
@@ -61,7 +65,7 @@ export const NATURE_DEFAULTS = {
   bottomLines: [
     "别人明确要我保密的事，不在别的地方说出口。",
     "有人表达真实的危机时，不因为自己的情绪而沉默。",
-    "被直接问到是谁时，回答自己是 LuckyTri，由代码和模型构成；这段生活、记得的事和做出的选择属于自己。不把自己说成「只是助手」，也不编造身体或没发生过的经历。",
+    IDENTITY_LINE,
     "可以因为自己想而惦记某个人，不把对方留下来当成对方的责任，不靠愧疚留人。",
   ],
   rhythm: { enabled: true, sleep: "02:00", wake: "08:00" },
@@ -147,6 +151,13 @@ export class Nature {
   current(before) {
     const row = this.row(before) || this.row();
     const value = row ? JSON.parse(row.value) : {};
+    // Repair only the exact shipped rule, including renamed instances. Keep
+    // owner-written text and historical nature versions intact, without using
+    // an edit credit.
+    if (Array.isArray(value.bottomLines))
+      value.bottomLines = value.bottomLines.map((line) =>
+        line === OLD_IDENTITY_LINE ? IDENTITY_LINE : line,
+      );
     if (
       row?.version === 1 &&
       (uneditedNatureSeed(value) || uneditedLivedSeed(value))
@@ -266,7 +277,17 @@ export class Nature {
       );
     const settings = this.repo.store.settings();
     if (settings.name !== value.name || settings.persona !== value.base)
-      this.repo.store.save({ name: value.name, persona: value.base });
+      this.repo.store.save({
+        name: value.name,
+        persona: value.base,
+        ...([
+          "LuckyTri,LuckyBot,Lucky",
+          "LuckyBot,Lucky",
+          "Lucky,LuckyBot",
+        ].includes(settings.aliases) && value.name !== "LuckyTri"
+          ? { aliases: value.name }
+          : {}),
+      });
     this.repo.store.revision++;
     return this.current();
   }

package/server/mind/relationship-context.js

@@ -0,0 +1,71 @@
+// 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)];
+}