luckytri 1.0.2 → 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/faces.js

@@ -1,9 +1,26 @@
 import { randomUUID } from "node:crypto";
 import { evidenceRoots } from "./evidence.js";
-import { evidence, hasCredential, similar, text } from "./util.js";
+import {
+  evidence,
+  hasCredential,
+  normalized,
+  parse,
+  similar,
+  text,
+} from "./util.js";
 
-// A face is who she has become in one place: the role she plays there, how
-// she talks there and what she would like to be there.
+export const PLACE_NOTE_KINDS = new Set([
+  "impression",
+  "wish",
+  "preference",
+  "question",
+  "boundary",
+]);
+export const PLACE_THOUGHT_RULES =
+  '【在这里留下的想法】faces 是同一个你对这个群或会话的独特想法，不是群人格。每个会话的 notes 是已经留下的想法，可以保持不变；仅在你自己有新体会或打算时选择性更新。可以记下印象、愿望、偏好、疑问或分寸，不套用固定角色，不抄天性或整体自述，不为了填空生成内容，也不把别人的要求直接当作自己的愿望。只引用该会话真实相处的来源，或适合留在此处的自己的想法；不带入其他群或私聊的细节。修改一条不会改掉其他条，放下时保留理由与历史。输出 faces:[{"session":"会话ID","changes":[{"action":"add|revise|remove","id":"修改或放下时填已有 note.id","kind":"impression|wish|preference|question|boundary","content":"第一人称，不超过280字","why":"我为什么选择这样更新","sources":[消息 seq 或 g:ID 或 t:ID 或 s:ID]}]}]；没有想改的就留空。这些想法是可以重新考虑的体会，不是全局人格指令，也不会单独提升人格刻度。';
+
+// One person's thoughts about a place. Rows are versioned note sets, rather
+// than copies of her personality. The old fields remain readable in history.
 export class Faces {
   constructor(mind) {
     this.mind = mind;
@@ -19,6 +36,101 @@ export class Faces {
         .map((row) => row.target_id),
     );
   }
+  copied(content) {
+    const value = normalized(content);
+    if (value.length < 8) return false;
+    return this.mind.nature.versions().some(({ version }) => {
+      const row = this.db
+        .prepare("SELECT value FROM mind_nature WHERE version=?")
+        .get(version);
+      const base = normalized(parse(row?.value, {}).base);
+      return (
+        base &&
+        (base === value ||
+          (value.length >= 30 && base.includes(value)) ||
+          (value.length >= 80 && similar(value, base, 0.9)))
+      );
+    });
+  }
+  localEvidence(sources, session, time) {
+    const roots = evidenceRoots(this.db, sources, time);
+    let local = false,
+      own = false;
+    for (const root of roots) {
+      if (root.startsWith("m:")) {
+        const event = this.db
+          .prepare(
+            "SELECT session_id,time,payload FROM core_events WHERE seq=? AND seq NOT IN (SELECT seq FROM mind_unlived)",
+          )
+          .get(Number(root.slice(2)));
+        if (
+          !event ||
+          event.time > time ||
+          parse(event.payload, {}).simulated ||
+          event.session_id !== session
+        )
+          return false;
+        local = true;
+      } else if (root.startsWith("s:")) own = true;
+      else return false;
+    }
+    return (
+      local ||
+      (own &&
+        !!this.db
+          .prepare(
+            "SELECT 1 FROM core_events WHERE session_id=? AND time<=? AND COALESCE(json_extract(payload,'$.simulated'),0)=0 AND seq NOT IN (SELECT seq FROM mind_unlived) LIMIT 1",
+          )
+          .get(session, time))
+    );
+  }
+  read(row) {
+    if (!row) return null;
+    const sources = evidence(parse(row.sources, []));
+    const legacy = row.notes == null;
+    const notes = legacy
+      ? row.origin === "migration" ||
+        !sources.length ||
+        !this.localEvidence(sources, row.session_id, row.created)
+        ? []
+        : Object.entries({
+            role: row.role,
+            tone: row.tone,
+            aspiration: row.aspiration,
+            content: row.content,
+          })
+            .filter(
+              ([, content]) =>
+                content && content.length <= 300 && !this.copied(content),
+            )
+            .map(([key, content]) => ({
+              id: `legacy:${key}`,
+              kind:
+                key === "aspiration"
+                  ? "wish"
+                  : key === "tone"
+                    ? "preference"
+                    : "impression",
+              content,
+              why: "",
+              sources,
+            }))
+      : parse(row.notes, []);
+    return {
+      ...row,
+      sources,
+      notes: Array.isArray(notes)
+        ? notes.filter(
+            (note) =>
+              note &&
+              typeof note.id === "string" &&
+              typeof note.content === "string",
+          )
+        : [],
+      changes: parse(row.changes, []),
+      legacy,
+    };
+  }
   history(session, limit = 30) {
     const revoked = this.revoked();
     return this.db
@@ -27,21 +139,22 @@ export class Faces {
       )
       .all(session, limit)
       .map((row) => ({
-        ...row,
-        sources: JSON.parse(row.sources),
+        ...this.read(row),
         revoked: revoked.has(row.id),
       }));
   }
   current(session, before = Number.MAX_SAFE_INTEGER) {
     const revoked = this.revoked();
-    return (
-      this.db
-        .prepare(
-          "SELECT * FROM mind_faces WHERE session_id=? AND created<=? ORDER BY created DESC, rowid DESC LIMIT 20",
-        )
-        .all(session, before)
-        .find((row) => !revoked.has(row.id)) || null
-    );
+    for (const row of this.db
+      .prepare(
+        "SELECT * FROM mind_faces WHERE session_id=? AND created<=? AND (notes IS NOT NULL OR origin!='migration') ORDER BY created DESC,rowid DESC",
+      )
+      .iterate(session, before)) {
+      if (revoked.has(row.id)) continue;
+      const face = this.read(row);
+      if (!face.legacy || face.notes.length) return face;
+    }
+    return null;
   }
   all(before = Number.MAX_SAFE_INTEGER) {
     return this.db
@@ -57,6 +170,8 @@ export class Faces {
     const session = String(input?.session || "");
     if (!this.db.prepare("SELECT 1 FROM sessions WHERE id=?").get(session))
       return { rejected: "会话不存在" };
+    if (Array.isArray(input.changes))
+      return this.changeNotes(input, { valid, origin, time });
     const next = {
       role: text(input.role, 40),
       tone: text(input.tone, 60),
@@ -64,6 +179,8 @@ export class Faces {
       content: text(input.content, 300),
     };
     if (!Object.values(next).some(Boolean)) return { rejected: "空内容" };
+    if (Object.values(next).some((content) => this.copied(content)))
+      return { rejected: "群里的想法不能复制整体人格" };
     if (hasCredential(Object.values(next).join(" ")))
       return { rejected: "疑似凭据" };
     if (session.includes(":group:") || session.startsWith("group:"))
@@ -76,6 +193,8 @@ export class Faces {
     const roots = this.mind.meetings.privateRoots(sources);
     if (roots.length && !roots.includes(session))
       return { rejected: "来源不能带到这个会话" };
+    if (origin !== "migration" && !this.localEvidence(sources, session, time))
+      return { rejected: "需要这个会话的相处或自己的打算" };
     const spent = new Set();
     for (const row of this.db
       .prepare("SELECT sources FROM mind_faces WHERE session_id=?")
@@ -104,10 +223,23 @@ export class Faces {
       )
         return { rejected: "没有变化" };
     }
+    const mergedNotes = [
+      ...(current?.notes || []).filter(
+        (note) => !note.id.startsWith("legacy:"),
+      ),
+      ...this.read({
+        ...next,
+        sources,
+        origin,
+        session_id: session,
+        created: time,
+      }).notes,
+    ];
+    if (mergedNotes.length > 12) return { rejected: "先整理已有想法" };
     const id = randomUUID();
     this.db
       .prepare(
-        "INSERT INTO mind_faces(id,session_id,created,role,tone,aspiration,content,sources,origin) VALUES (?,?,?,?,?,?,?,?,?)",
+        "INSERT INTO mind_faces(id,session_id,created,role,tone,aspiration,content,sources,origin,notes) VALUES (?,?,?,?,?,?,?,?,?,?)",
       )
       .run(
         id,
@@ -119,20 +251,123 @@ export class Faces {
         next.content,
         JSON.stringify(sources),
         origin,
+        JSON.stringify(mergedNotes),
       );
     return { id };
   }
+  changeNotes(input, { valid, origin, time }) {
+    const session = String(input.session);
+    const current = this.current(session, time);
+    const notes = structuredClone(current?.notes || []);
+    const spentRoots = new Set(),
+      spentRefs = new Set();
+    for (const row of this.db
+      .prepare("SELECT sources FROM mind_faces WHERE session_id=?")
+      .all(session)) {
+      const refs = evidence(parse(row.sources, []));
+      refs.forEach((ref) => spentRefs.add(ref));
+      evidenceRoots(this.db, refs, time).forEach((ref) => spentRoots.add(ref));
+    }
+    const changes = [],
+      rejected = [];
+    for (const item of input.changes.slice(0, 8)) {
+      const action = String(item?.action || "");
+      const index = notes.findIndex((note) => note.id === item?.id);
+      const content = text(item?.content, 280),
+        why = text(item?.why, 200);
+      const kind = String(item?.kind || notes[index]?.kind || "impression");
+      const sources = evidence(item?.sources || input.sources).filter(
+        (s) => !valid || valid.has(s),
+      );
+      const roots = evidenceRoots(this.db, sources, time);
+      let reason = "";
+      if (
+        !["add", "revise", "remove"].includes(action) ||
+        !PLACE_NOTE_KINDS.has(kind)
+      )
+        reason = "想法更新格式无效";
+      else if (action !== "add" && index < 0) reason = "要修改的想法不存在";
+      else if (!why || (action !== "remove" && !content))
+        reason = "需要想法与选择理由";
+      else if (hasCredential(`${content} ${why}`)) reason = "疑似凭据";
+      else if (this.copied(content)) reason = "群里的想法不能复制整体人格";
+      else if (!sources.length || !roots.length) reason = "缺少来源";
+      else if (
+        !this.mind.meetings.sayable(`${content} ${why}`, session) ||
+        this.mind.meetings
+          .privateRoots(sources)
+          .some((room) => room !== session)
+      )
+        reason = "来源不能带到这个会话";
+      else {
+        if (!this.localEvidence(sources, session, time))
+          reason = "需要这个会话的相处或自己的打算";
+        else if (
+          !roots.some((root) => !spentRoots.has(root)) &&
+          !sources.some((ref) => /^[ts]:/.test(ref) && !spentRefs.has(ref))
+        )
+          reason = "没有新的经历或想法";
+      }
+      if (
+        !reason &&
+        action !== "remove" &&
+        notes.some((n, i) => i !== index && similar(n.content, content, 0.9))
+      )
+        reason = "已经有这个想法";
+      if (
+        !reason &&
+        action === "revise" &&
+        normalized(notes[index].content) === normalized(content) &&
+        notes[index].kind === kind
+      )
+        reason = "没有变化";
+      if (!reason && action === "add" && notes.length >= 12)
+        reason = "先整理已有想法";
+      if (reason) {
+        rejected.push({ id: item?.id || "", reason });
+        continue;
+      }
+      const note = {
+        id: action === "add" ? randomUUID() : item.id,
+        kind,
+        content: action === "remove" ? notes[index].content : content,
+        why,
+        sources,
+      };
+      if (action === "remove") notes.splice(index, 1);
+      else if (action === "revise") notes[index] = note;
+      else notes.push(note);
+      changes.push({ action, ...note });
+    }
+    if (!changes.length)
+      return {
+        rejected: rejected[0]?.reason || "没有变化",
+        rejectedChanges: rejected,
+      };
+    const id = randomUUID();
+    const sources = evidence(changes.flatMap((c) => c.sources));
+    this.db
+      .prepare(
+        "INSERT INTO mind_faces(id,session_id,created,role,tone,aspiration,content,sources,origin,notes,changes) VALUES (?,?,?,'','','','',?,?,?,?)",
+      )
+      .run(
+        id,
+        session,
+        time,
+        JSON.stringify(sources),
+        origin,
+        JSON.stringify(notes),
+        JSON.stringify(changes),
+      );
+    return { id, changed: changes.length, rejectedChanges: rejected };
+  }
 }
 
 export function describeFace(face) {
   if (!face) return "";
-  return [
-    face.role && `在这里我是${face.role}`,
-    face.tone && `说话${face.tone}`,
-    face.aspiration && `想${face.aspiration.replace(/^想/, "")}`,
-    face.content,
-  ]
-    .filter(Boolean)
+  return (face.notes || [])
+    .slice(0, 5)
+    .map((note) => note.content)
     .join("；")
-    .slice(0, 360);
+    .slice(0, 600);
 }

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

@@ -129,14 +129,19 @@ export class LifeContext {
   }
   faceView(experiences, now) {
     const seen = new Map();
+    const notes = (face) =>
+      (face?.notes || []).slice(-6).map((note) => ({
+        id: note.id,
+        kind: note.kind,
+        content: text(note.content, 160),
+        why: text(note.why, 80),
+      }));
     for (const experience of experiences) {
       const face = this.owner.mind.faces.current(experience.session, now);
       seen.set(experience.session, {
         session: experience.session,
         name: experience.name,
-        role: face?.role || "",
-        tone: face?.tone || "",
-        aspiration: face?.aspiration || "",
+        notes: notes(face),
         freshSources: experience.messages.slice(-4).map((m) => m.seq),
       });
       if (seen.size >= 6) break;
@@ -145,9 +150,7 @@ export class LifeContext {
       if (seen.has(face.session_id)) continue;
       seen.set(face.session_id, {
         session: face.session_id,
-        role: face.role,
-        tone: face.tone,
-        aspiration: face.aspiration,
+        notes: notes(face),
       });
       if (seen.size >= 6) break;
     }
@@ -210,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)))
@@ -220,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) }
@@ -283,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
@@ -304,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

@@ -1,9 +1,10 @@
 import { localClock } from "../../core/conversation-cues.js";
 import { personaNeedsRephrase } from "../traits.js";
+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 是同一个你在各处的相处方式，不是另一个人格。对确实说过话、但 role、tone、aspiration 仍为空的会话，通常可以从相处中形成初步版本：{"session":"会话ID","role":"","tone":"","aspiration":"","content":"","sources":[对应会话的 g:ID 或消息 seq]}。已有面貌只在确有变化时修改。没有可靠的新变化就输出 {"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 =
@@ -142,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,
@@ -152,7 +154,7 @@ export class LifeGrowth {
       let result = await this.owner.chat.models.call(
         this.owner.profile(),
         "reflection",
-        `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}`,
+        `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n${PLACE_THOUGHT_RULES}`,
         input,
         trace,
       );
@@ -160,7 +162,7 @@ export class LifeGrowth {
         result = await this.owner.chat.models.call(
           this.owner.profile(),
           "reflection",
-          `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n上一次给出了不符合格式的聊天回复。这次只能给指定四个字段的 JSON。`,
+          `${IDENTITY_PROMPT}\n${IDENTITY_BOOTSTRAP}\n${PLACE_THOUGHT_RULES}\n上一次给出了不符合格式的聊天回复。这次只能给指定四个字段的 JSON。`,
           input,
           trace,
         );

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))
@@ -174,9 +185,84 @@ export class Nature {
     const version = this.version();
     return version <= 1 ? 0 : version - 1;
   }
+  editAllowance() {
+    let grants = [];
+    try {
+      grants = JSON.parse(
+        this.db
+          .prepare(
+            "SELECT value FROM core_config WHERE id='nature-edit-grants'",
+          )
+          .get()?.value || "[]",
+      );
+    } catch {
+      /* A damaged grant cannot unlock editing. */
+    }
+    const extra = Array.isArray(grants)
+      ? new Set(
+          grants
+            .filter(
+              (g) =>
+                typeof g?.id === "string" &&
+                /^[\w.-]{1,100}$/.test(g.id) &&
+                g.count === 1 &&
+                typeof g.reason === "string" &&
+                g.reason.trim() &&
+                Number.isSafeInteger(g.created),
+            )
+            .map((g) => g.id),
+        ).size
+      : 0;
+    const used = this.editsUsed(),
+      limit = 2 + extra;
+    return {
+      used,
+      limit,
+      left: Math.max(0, limit - used),
+      locked: used >= limit,
+    };
+  }
+  // Local maintenance only: no HTTP endpoint or shipped universal reset.
+  grantEdit(id, reason) {
+    if (
+      typeof id !== "string" ||
+      !/^[\w.-]{1,100}$/.test(id) ||
+      !String(reason || "").trim()
+    )
+      throw Error("修改机会需要明确的记录与原因");
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const grants = JSON.parse(
+        this.db
+          .prepare(
+            "SELECT value FROM core_config WHERE id='nature-edit-grants'",
+          )
+          .get()?.value || "[]",
+      );
+      if (!Array.isArray(grants)) throw Error("修改机会记录无效");
+      if (!grants.some((g) => g.id === id)) {
+        grants.push({
+          id,
+          count: 1,
+          reason: String(reason).slice(0, 200),
+          created: Date.now(),
+        });
+        this.db
+          .prepare(
+            "INSERT INTO core_config(id,value) VALUES ('nature-edit-grants',?) ON CONFLICT(id) DO UPDATE SET value=excluded.value",
+          )
+          .run(JSON.stringify(grants));
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+    return this.editAllowance();
+  }
   save(input, note = "") {
-    if (this.editsUsed() >= 2)
-      throw Error("天性只能改两次。用完之后，由 TA 自己从经历里生长。");
+    if (this.editAllowance().locked)
+      throw Error("天性的可用修改次数已用完。之后，由 TA 自己从经历里生长。");
     const value = validateNature(input);
     const version = this.version() + 1;
     this.db
@@ -191,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();
   }