luckytri 1.0.1 → 1.0.3

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/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;
     }

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":[]}。';
+  '你是 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":[]}。';
 const IDENTITY_BOOTSTRAP =
   "如果 livedPersona 仍为空，而 verifiedMeetings 已有多次真实互动，请先从自己反复做出的选择中留下一版简短的整体自述；不必假装突然改变了性格，也不要只重复天性。之后的版本才需要比较哪里真正改变。自述只写自己的倾向，不写对方名字、群名或具体私事。";
 const PERSONA_REPHRASE_PROMPT =
@@ -152,7 +153,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 +161,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

@@ -174,9 +174,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

package/server/mind/schema.js

@@ -65,6 +65,9 @@ export function migrateMind(db, store) {
       db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
   };
   addColumn("core_memories", "discretion", "TEXT NOT NULL DEFAULT 'open'");
+  // NULL distinguishes legacy faces from a deliberately emptied note set.
+  addColumn("mind_faces", "notes", "TEXT");
+  addColumn("mind_faces", "changes", "TEXT NOT NULL DEFAULT '[]'");
   addColumn("core_memories", "superseded_by", "TEXT");
   addColumn("mind_attention", "deferred", "INTEGER NOT NULL DEFAULT 0");
   addColumn("mind_thoughts", "resolved_at", "INTEGER");

package/server/mind/view.js

@@ -136,6 +136,9 @@ export function innerView(
       ? {
           here: describeFace({
             ...face,
+            notes: face.notes.filter((note) =>
+              spoken(`${note.content} ${note.why}`),
+            ),
             role: spoken(face.role),
             tone: spoken(face.tone),
             aspiration: spoken(face.aspiration),

package/server/storage/archive.js

@@ -194,7 +194,7 @@ export function restoreToNewFile(source, destination) {
   }
 }
 
-export function prepareDatabaseMigration(file) {
+export function prepareDatabaseMigration(file, { quiet = false } = {}) {
   if (file === ":memory:" || !existsSync(file)) return null;
   const db = new DatabaseSync(file, { readOnly: true });
   let version, hasData;
@@ -211,9 +211,10 @@ export function prepareDatabaseMigration(file) {
     db.close();
   }
   if (version === DATABASE_VERSION || !hasData) return null;
-  console.log(
-    `正在把数据库从 v${version} 升级到 v${DATABASE_VERSION}。会先复制整份数据，记录越多越久，请不要关闭窗口。`,
-  );
+  if (!quiet)
+    console.log(
+      `正在把数据库从 v${version} 升级到 v${DATABASE_VERSION}。会先复制整份数据，记录越多越久，请不要关闭窗口。`,
+    );
   const directory = join(dirname(resolve(file)), "backups");
   mkdirSync(directory, { recursive: true });
   const target = join(

package/server/storage/backup-cleanup.js

@@ -25,6 +25,7 @@ const DEFAULTS = Object.freeze({
 function kind(scope, name) {
   if (scope === "root")
     return /^friend\.pre-[\w-]+\.db$/.test(name) ? "snapshot" : null;
+  if (/^luckytri-before-import-\d+-[\da-f]{8}\.db$/.test(name)) return "import";
   if (/^luckytri-auto-\d{4}-\d\d-\d\dT[\d-]+Z\.db$/.test(name)) return "auto";
   if (/^luckytri-migration-v\d+-to-v\d+-\d+-[\da-f]{8}\.db$/.test(name))
     return "migration";