luckytri 1.0.3 → 1.0.4

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

@@ -213,6 +213,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 +227,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 +291,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 +317,7 @@ export class LifeContext {
         name: p.name,
         feel: p.feel,
         ...(p.impression ? { impression: p.impression } : {}),
+        ...(p.relationship ? { relationship: p.relationship } : {}),
       }));
   }
 }

package/server/mind/life/growth.js

@@ -4,7 +4,7 @@ import { PLACE_THOUGHT_RULES } from "../faces.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 =
@@ -143,6 +143,7 @@ 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),
         faces: this.owner.faceView(experiences, now),
         verifiedMeetings: this.owner.identityMeetings(
           now,

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/relationships.js

@@ -0,0 +1,279 @@
+import { randomUUID } from "node:crypto";
+import { parseSessionKey } from "../channels/session-key.js";
+import { hasCredential, text } from "./util.js";
+import { normalized } from "./util.js";
+import { leaks } from "./guard.js";
+
+export const RELATIONSHIP_ROLES = [
+  "妹妹",
+  "姐姐",
+  "弟弟",
+  "哥哥",
+  "朋友",
+  "伙伴",
+];
+const FAMILY = new Set(RELATIONSHIP_ROLES.slice(0, 4));
+const scope = (room) => {
+  try {
+    return room ? parseSessionKey(room) : null;
+  } catch {
+    return null;
+  }
+};
+
+// Account identity and an explicit arrangement, never invented encounters or
+// earned trust. Changes append history; nickname equality does not bind peers.
+export class Relationships {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  version() {
+    return this.db
+      .prepare("SELECT COALESCE(MAX(rowid),0) n FROM mind_relationships")
+      .get().n;
+  }
+  current(subject, { now = Date.now(), room = "" } = {}) {
+    const place = scope(room);
+    const row = this.db
+      .prepare(
+        "SELECT * FROM mind_relationships WHERE subject_id=? AND created<=? ORDER BY created DESC,rowid DESC",
+      )
+      .all(String(subject), now)
+      .find(
+        (r) =>
+          !place ||
+          (r.channel === place.channel &&
+            (r.account_id === "_" || r.account_id === place.accountId)),
+      );
+    return row?.status === "active" ? row : null;
+  }
+  visible(row, room) {
+    if (!row || !room || row.discretion === "open") return !!row;
+    const place = scope(room);
+    return (
+      place?.kind === "private" &&
+      place.nativeId === row.subject_id &&
+      place.channel === row.channel &&
+      (row.account_id === "_" || place.accountId === row.account_id)
+    );
+  }
+  discloses(bubbles, room, now = Date.now()) {
+    const hidden = this.list(now).filter((row) => !this.visible(row, room));
+    if (
+      leaks(
+        bubbles,
+        hidden.filter((r) => r.note).map((r) => ({ content: r.note })),
+      ).length
+    )
+      return true;
+    const said = normalized(bubbles.join(" "));
+    const english = {
+      妹妹: "youngersister",
+      姐姐: "oldersister",
+      弟弟: "youngerbrother",
+      哥哥: "olderbrother",
+      朋友: "friend",
+      伙伴: "companion",
+    };
+    return hidden.some((row) => {
+      const names = [
+        row.name,
+        this.mind.bonds.name(row.subject_id),
+        row.subject_id,
+      ]
+        .filter(Boolean)
+        .map(normalized);
+      const role = normalized(row.peer_role),
+        en = english[row.peer_role] || role;
+      return names.some((name) =>
+        [
+          "我的" + role + name,
+          "我" + role + name,
+          name + "是我的" + role,
+          name + "是我" + role,
+          name + role,
+          "my" + en + name,
+          name + "ismy" + en,
+        ].some((line) => said.includes(line)),
+      );
+    });
+  }
+  weight(row) {
+    return row ? (FAMILY.has(row.peer_role) ? 0.15 : 0.05) : 0;
+  }
+  view(row, room = "") {
+    if (!this.visible(row, room)) return null;
+    return {
+      id: row.id,
+      subjectId: row.subject_id,
+      channel: row.channel,
+      accountId: row.account_id,
+      kind: row.kind,
+      name: row.name,
+      peerRole: row.peer_role,
+      selfRole: row.self_role,
+      discretion: row.discretion,
+      note: row.note,
+      created: row.created,
+      origin: "owner",
+    };
+  }
+  list(now = Date.now()) {
+    const seen = new Set();
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_relationships WHERE created<=? ORDER BY created DESC,rowid DESC",
+      )
+      .all(now)
+      .filter((r) => {
+        const key = JSON.stringify([r.subject_id, r.channel, r.account_id]);
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return r.status === "active";
+      });
+  }
+  history(subject, limit = 30) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_relationships WHERE subject_id=? ORDER BY created DESC,rowid DESC LIMIT ?",
+      )
+      .all(String(subject), limit);
+  }
+  save(input, now = Date.now()) {
+    const subject = text(input?.subjectId, 128),
+      channel = String(input?.channel || "onebot"),
+      account = text(input?.accountId || "_", 128);
+    if (
+      String(input?.subjectId || "").length > 128 ||
+      String(input?.accountId || "").length > 128 ||
+      !/^[\w.-]{1,128}$/.test(subject) ||
+      ["bot", "self", "_"].includes(subject) ||
+      !["onebot", "qqbot"].includes(channel) ||
+      !/^[\w.-]{1,128}$/.test(account) ||
+      (channel === "onebot" && !/^\d+$/.test(subject))
+    )
+      throw Error("关系对象账号无效");
+    if (channel === "qqbot" && account === "_")
+      throw Error("官方机器人关系需要指定应用账号");
+    if (
+      this.db
+        .prepare("SELECT 1 FROM core_events WHERE account_id=? LIMIT 1")
+        .get(subject)
+    )
+      throw Error("不能把当前实例绑定为自己的关系对象");
+    const kind = String(input.kind || "human"),
+      role = text(input.peerRole, 24),
+      name = text(input.name, 40),
+      note = text(input.note, 300),
+      discretion = input.discretion || "open";
+    if (
+      !["human", "bot"].includes(kind) ||
+      !role ||
+      String(input.peerRole).length > 24 ||
+      String(input.name || "").length > 40 ||
+      String(input.note || "").length > 300 ||
+      !["open", "private", "secret"].includes(discretion)
+    )
+      throw Error("关系设置无效");
+    const gender = this.mind.nature.current(now).gender;
+    const older =
+      gender === "female" ? "姐姐" : gender === "male" ? "哥哥" : "年长手足";
+    const younger =
+      gender === "female" ? "妹妹" : gender === "male" ? "弟弟" : "年幼手足";
+    const opposite = {
+      妹妹: older,
+      弟弟: older,
+      姐姐: younger,
+      哥哥: younger,
+      朋友: "朋友",
+      伙伴: "伙伴",
+    };
+    const selfRole = text(input.selfRole || opposite[role] || "", 24);
+    if (
+      !selfRole ||
+      String(input.selfRole || "").length > 24 ||
+      hasCredential([role, selfRole, name, note].join(" "))
+    )
+      throw Error("关系称呼或备注无效");
+    const room = `${channel}:${account}:private:${subject}`,
+      previous = this.current(subject, { now, room });
+    if (
+      input.expectedId !== undefined &&
+      input.expectedId !== (previous?.id || null)
+    )
+      throw Error("关系已经变化，请刷新后再修改");
+    if (
+      previous &&
+      previous.kind === kind &&
+      previous.peer_role === role &&
+      previous.self_role === selfRole &&
+      previous.name === name &&
+      previous.note === note &&
+      previous.discretion === discretion
+    )
+      return this.view(previous);
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db
+        .prepare(
+          "INSERT INTO mind_relationships(id,created,subject_id,channel,account_id,kind,name,peer_role,self_role,discretion,note,status) VALUES (?,?,?,?,?,?,?,?,?,?,?,'active')",
+        )
+        .run(
+          randomUUID(),
+          now,
+          subject,
+          channel,
+          account,
+          kind,
+          name,
+          role,
+          selfRole,
+          discretion,
+          note,
+        );
+      this.db
+        .prepare(
+          "INSERT INTO mind_people(user_id,name,first_seen,last_seen,sessions) VALUES (?,NULL,NULL,NULL,'[]') ON CONFLICT(user_id) DO NOTHING",
+        )
+        .run(subject);
+      this.db.exec("COMMIT");
+      this.mind.repo.store.revision++;
+      return this.view(this.current(subject, { now, room }));
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  end(subject, input = {}, now = Date.now()) {
+    if (
+      String(input.note || "").length > 300 ||
+      hasCredential(String(input.note || ""))
+    )
+      throw Error("关系称呼或备注无效");
+    const room = `${input.channel || "onebot"}:${input.accountId || "_"}:private:${subject}`,
+      row = this.current(subject, { now, room });
+    if (!row) throw Error("关系不存在或已解除");
+    if (input.expectedId !== undefined && input.expectedId !== row.id)
+      throw Error("关系已经变化，请刷新后再修改");
+    this.db
+      .prepare(
+        "INSERT INTO mind_relationships(id,created,subject_id,channel,account_id,kind,name,peer_role,self_role,discretion,note,status) VALUES (?,?,?,?,?,?,?,?,?,?,?,'ended')",
+      )
+      .run(
+        randomUUID(),
+        now,
+        row.subject_id,
+        row.channel,
+        row.account_id,
+        row.kind,
+        row.name,
+        row.peer_role,
+        row.self_role,
+        row.discretion,
+        text(input.note || "在管理台解除关系", 300),
+      );
+    this.mind.repo.store.revision++;
+    return { ended: true };
+  }
+}

package/server/mind/schema.js

@@ -26,6 +26,8 @@ export function migrateMind(db, store) {
     CREATE INDEX IF NOT EXISTS mind_self_thread ON mind_self(thread,created);
     CREATE TABLE IF NOT EXISTS mind_faces (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, created INTEGER NOT NULL, role TEXT NOT NULL DEFAULT '', tone TEXT NOT NULL DEFAULT '', aspiration TEXT NOT NULL DEFAULT '', content TEXT NOT NULL DEFAULT '', sources TEXT NOT NULL DEFAULT '[]', origin TEXT NOT NULL);
     CREATE INDEX IF NOT EXISTS mind_faces_session ON mind_faces(session_id,created);
+    CREATE TABLE IF NOT EXISTS mind_relationships(id TEXT PRIMARY KEY,created INTEGER NOT NULL,subject_id TEXT NOT NULL,channel TEXT NOT NULL,account_id TEXT NOT NULL,kind TEXT NOT NULL,name TEXT NOT NULL DEFAULT '',peer_role TEXT NOT NULL,self_role TEXT NOT NULL,discretion TEXT NOT NULL DEFAULT 'open',note TEXT NOT NULL DEFAULT '',status TEXT NOT NULL);
+    CREATE INDEX IF NOT EXISTS mind_relationships_subject ON mind_relationships(subject_id,channel,account_id,created);
     CREATE TABLE IF NOT EXISTS mind_thoughts (id TEXT PRIMARY KEY, created INTEGER NOT NULL, kind TEXT NOT NULL, content TEXT NOT NULL, sessions TEXT NOT NULL DEFAULT '[]', sources TEXT NOT NULL DEFAULT '[]', parent_id TEXT, importance REAL NOT NULL DEFAULT 0.5, revisit_at INTEGER, status TEXT NOT NULL DEFAULT 'open', hidden INTEGER NOT NULL DEFAULT 0, outreach TEXT NOT NULL DEFAULT '', outreach_session TEXT, outreach_status TEXT NOT NULL DEFAULT 'none', run_id TEXT);
     CREATE INDEX IF NOT EXISTS mind_thoughts_time ON mind_thoughts(created);
     CREATE TABLE IF NOT EXISTS mind_diary (id TEXT PRIMARY KEY, day TEXT NOT NULL, created INTEGER NOT NULL, content TEXT NOT NULL, mood TEXT, compare TEXT, sources TEXT NOT NULL DEFAULT '[]', run_id TEXT);

package/server/mind/time/tasks.js

@@ -367,7 +367,8 @@ export class Tasks {
         ? 2
         : task.priority) *
         100 +
-      Math.min(8, Number(person?.closeness || 0) * 8)
+      Math.min(8, Number(person?.closeness || 0) * 8) +
+      Math.min(2, Number(person?.relationalWeight || 0) * 8)
     );
   }
   arrange(

package/server/mind/view.js

@@ -179,6 +179,7 @@ export function innerView(
       (!bond.interactions &&
         !bond.impression &&
         !bond.lastChange &&
+        !bond.relationship &&
         bond.tension < 0.15)
     )
       continue;
@@ -186,6 +187,7 @@ export function innerView(
       id,
       name: bond.name,
       feel: bond.feel,
+      ...(bond.relationship ? { relationship: bond.relationship } : {}),
       ...(bond.impression && mind.meetings.sayable(bond.impression, session)
         ? { impression: bond.impression }
         : {}),

package/server/runtime/installation.js

@@ -0,0 +1,116 @@
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  readdirSync,
+  renameSync,
+  rmdirSync,
+  writeFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join, relative, isAbsolute } from "node:path";
+import { randomUUID } from "node:crypto";
+import { compareVersions } from "../studio/updates.js";
+export const UPDATE_ID =
+  /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+export const updateRoot = (home) => join(home, "runtime");
+export function updatePath(home, id) {
+  if (!UPDATE_ID.test(String(id))) throw Error("更新任务无效");
+  const root = updateRoot(home),
+    path = join(root, "releases", id);
+  // Managed paths cannot be symlinked into an unrelated installation.
+  for (const p of [root, join(root, "releases"), path])
+    if (existsSync(p) && lstatSync(p).isSymbolicLink())
+      throw Error("更新目录无效");
+  return path;
+}
+export function readActive(home) {
+  try {
+    return JSON.parse(
+      readFileSync(join(updateRoot(home), "active.json"), "utf8"),
+    );
+  } catch {
+    return null;
+  }
+}
+export function atomicJson(file, value) {
+  const tmp = `${file}.${randomUUID()}.partial`;
+  try {
+    writeFileSync(tmp, JSON.stringify(value), {
+      mode: 0o600,
+      flag: "wx",
+      flush: true,
+    });
+    renameSync(tmp, file);
+  } finally {
+    if (existsSync(tmp)) unlinkSync(tmp);
+  }
+}
+export function writeActive(home, value) {
+  const root = updateRoot(home);
+  if (value) updatePath(home, value.id);
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  if (value) atomicJson(join(root, "active.json"), value);
+  else if (existsSync(join(root, "active.json")))
+    unlinkSync(join(root, "active.json"));
+}
+export function installedRelease(home, id, version) {
+  const slot = updatePath(home, id),
+    root = join(slot, "node_modules", "luckytri");
+  const part = relative(realpathSync(slot), realpathSync(root));
+  if (part.startsWith("..") || isAbsolute(part)) throw Error("更新目录无效");
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  if (
+    pkg.name !== "luckytri" ||
+    pkg.version !== version ||
+    !existsSync(join(root, "server", "index.js")) ||
+    !existsSync(join(root, "public", "app", "index.html"))
+  )
+    throw Error("更新程序校验失败");
+  return root;
+}
+export function resolveInstallation(home, basePackage, baseVersion) {
+  const active = readActive(home);
+  if (active) {
+    try {
+      // An explicit newer/equal global npm or source install takes precedence.
+      if (compareVersions(active.version, baseVersion) > 0)
+        return {
+          package: installedRelease(home, active.id, active.version),
+          version: active.version,
+        };
+    } catch {
+      /* Invalid receipts never route the launcher to arbitrary code. */
+    }
+  }
+  return { package: basePackage, version: baseVersion };
+}
+export function pruneInstallations(home, keep) {
+  const root = join(updateRoot(home), "releases");
+  if (!existsSync(root)) return;
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (
+      !entry.isDirectory() ||
+      !UPDATE_ID.test(entry.name) ||
+      keep.includes(entry.name)
+    )
+      continue;
+    const path = updatePath(home, entry.name),
+      part = relative(realpathSync(root), realpathSync(path));
+    if (!part || part.startsWith("..") || isAbsolute(part))
+      throw Error("更新目录无效");
+    // File removal uses unlink, including Unicode/short Windows paths where
+    // recursive rm can return without actually removing a lock or directory.
+    const remove = (directory) => {
+      for (const child of readdirSync(directory, { withFileTypes: true })) {
+        const target = join(directory, child.name);
+        if (child.isDirectory() && !child.isSymbolicLink()) remove(target);
+        else unlinkSync(target);
+      }
+      rmdirSync(directory);
+    };
+    remove(path);
+  }
+}