luckytri 1.0.0

package/server/mind/days.js

@@ -0,0 +1,210 @@
+import { localClock } from "../core/conversation-cues.js";
+import { lifeDayKey, lifeDayStart, lifeSpan } from "./nature.js";
+import { DAY } from "./util.js";
+
+const MINUTE = 60000;
+const LIVE = "COALESCE(json_extract(payload,'$.simulated'),0)=0";
+const BACKFILL_DAYS = 14;
+const MILESTONES = [100, 200, 300, 500, 1000];
+
+// The days she has actually lived. Things fade by how much life has passed
+// since, not by the calendar, so a silent month does not wear her away.
+export class Days {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+    this.rolled = null;
+  }
+  key(time, nature = this.mind.nature.current(time)) {
+    return lifeDayKey(nature, time, this.mind.timeZone());
+  }
+  start(time, nature = this.mind.nature.current(time)) {
+    return lifeDayStart(nature, time, this.mind.timeZone());
+  }
+  // Each finished day is written once; cheap enough to call every minute.
+  rollup(now = Date.now()) {
+    const nature = this.mind.nature.current(now);
+    const today = this.key(now, nature);
+    if (this.rolled === today) return 0;
+    const has = this.db.prepare("SELECT 1 FROM mind_days WHERE day=?");
+    let end = this.start(now, nature);
+    let written = 0;
+    for (let i = 0; i < BACKFILL_DAYS; i++) {
+      const start = this.start(end - MINUTE, nature);
+      const day = this.key(start, nature);
+      if (!has.get(day) && this.write(day, start, end, now)) written++;
+      end = start;
+    }
+    this.rolled = today;
+    return written;
+  }
+  write(day, start, end, now) {
+    const events = this.db
+      .prepare(
+        `SELECT COUNT(*) n, COUNT(DISTINCT CASE WHEN role='user' THEN json_extract(payload,'$.userId') END) people FROM core_events WHERE time>=? AND time<? AND ${LIVE} AND seq NOT IN (SELECT seq FROM mind_unlived)`,
+      )
+      .get(start, end);
+    const felt = this.db
+      .prepare(
+        "SELECT SUM(valence*intensity) v, SUM(intensity) i, AVG(arousal) a, COUNT(*) n FROM mind_affect WHERE created>=? AND created<?",
+      )
+      .get(start, end);
+    const choices = this.db
+      .prepare(
+        "SELECT COUNT(*) n, COALESCE(SUM(choice!='silent'),0) spoke FROM mind_choices WHERE created>=? AND created<?",
+      )
+      .get(start, end);
+    const present = this.participated(start, end);
+    if (!events.n && !felt.n && !present) return false;
+    const round = (value) => Math.round(value * 100) / 100;
+    this.db
+      .prepare(
+        "INSERT OR IGNORE INTO mind_days(day,created,lived,events,valence,arousal,looked,spoke,people) VALUES (?,?,?,?,?,?,?,?,?)",
+      )
+      .run(
+        day,
+        now,
+        Number(present),
+        events.n,
+        felt.i > 0 ? round(felt.v / felt.i) : null,
+        felt.n ? round(felt.a) : null,
+        choices.n,
+        choices.spoke,
+        events.people,
+      );
+    return true;
+  }
+  // Days written when any messages counted as a life are put back, once she
+  // did not look, speak, or sit with them.
+  reconcile(now = Date.now()) {
+    const nature = this.mind.nature.current(now);
+    const zone = this.mind.timeZone();
+    const clear = this.db.prepare("UPDATE mind_days SET lived=0 WHERE day=?");
+    let changed = 0;
+    for (const row of this.db
+      .prepare(
+        "SELECT day FROM mind_days WHERE lived=1 AND looked=0 AND spoke=0",
+      )
+      .all()) {
+      const span = lifeSpan(nature, row.day, zone);
+      if (!span || this.participated(span.start, span.end)) continue;
+      clear.run(row.day);
+      changed++;
+    }
+    return changed;
+  }
+  // She looked, spoke, or sat with the day. Other people's messages do not count.
+  participated(start, end, { inclusive = false } = {}) {
+    const endOp = inclusive ? "<=" : "<";
+    return !!(
+      this.db
+        .prepare(
+          `SELECT 1 FROM mind_choices WHERE created>=? AND created${endOp}? AND (choice!='silent' OR COALESCE(occasion,'') NOT IN ('presence','outreach'))`,
+        )
+        .get(start, end) ||
+      this.db
+        .prepare(
+          `SELECT 1 FROM core_events WHERE role='assistant' AND time>=? AND time${endOp}? AND ${LIVE}`,
+        )
+        .get(start, end) ||
+      this.db
+        .prepare(
+          `SELECT 1 FROM mind_runs WHERE started>=? AND started${endOp}? AND (status IN ('written','complete','draft','experienced') OR (status='empty' AND (summary IS NULL OR COALESCE(json_extract(summary,'$.freshMessages'),0)>0)))`,
+        )
+        .get(start, end)
+    );
+  }
+  // Counts lived days after the day of a given moment, as known at `now`.
+  lived(now = Date.now()) {
+    const nature = this.mind.nature.current(now);
+    const days = this.db
+      .prepare(
+        "SELECT day FROM mind_days WHERE lived=1 AND created<=? ORDER BY day",
+      )
+      .all(now)
+      .map((row) => row.day);
+    const since = (time) => {
+      if (!days.length) return 0;
+      if (!time) return days.length;
+      const key = this.key(time, nature);
+      let lo = 0;
+      let hi = days.length;
+      while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (days[mid] <= key) lo = mid + 1;
+        else hi = mid;
+      }
+      return days.length - lo;
+    };
+    return { count: days.length, since };
+  }
+  recent({ now = Date.now(), limit = 14 } = {}) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_days WHERE created<=? ORDER BY day DESC LIMIT ?",
+      )
+      .all(now, limit);
+  }
+  // Her first day: the first thing that happened to her, or her first nature.
+  born() {
+    const event = this.db
+      .prepare(
+        `SELECT MIN(time) t FROM core_events WHERE ${LIVE} AND seq NOT IN (SELECT seq FROM mind_unlived)`,
+      )
+      .get().t;
+    const nature = this.db
+      .prepare("SELECT MIN(created) t FROM mind_nature")
+      .get().t;
+    const times = [event, nature].filter((t) => Number.isFinite(t));
+    return times.length ? Math.min(...times) : null;
+  }
+  dayOfLife(now = Date.now()) {
+    const born = this.born();
+    if (!born || born > now) return 1;
+    const zone = this.mind.timeZone();
+    const from = Date.parse(
+      `${localClock(born, zone).local.slice(0, 10)}T00:00:00Z`,
+    );
+    const to = Date.parse(
+      `${localClock(now, zone).local.slice(0, 10)}T00:00:00Z`,
+    );
+    return Math.round((to - from) / DAY) + 1;
+  }
+  // Round numbers and yearly returns: of her own days, and of meeting people
+  // she has come to know.
+  anniversaries(now = Date.now(), { limit = 3 } = {}) {
+    const zone = this.mind.timeZone();
+    const today = localClock(now, zone).local.slice(0, 10);
+    const out = [];
+    const mark = (first, label) => {
+      const day = localClock(first, zone).local.slice(0, 10);
+      const days =
+        Math.round(
+          (Date.parse(`${today}T00:00:00Z`) - Date.parse(`${day}T00:00:00Z`)) /
+            DAY,
+        ) + 1;
+      const years = Number(today.slice(0, 4)) - Number(day.slice(0, 4));
+      if (years >= 1 && day.slice(5) === today.slice(5))
+        return `${label}满 ${years} 年`;
+      if (MILESTONES.includes(days)) return `${label}的第 ${days} 天`;
+      return null;
+    };
+    const born = this.born();
+    if (born && born <= now) {
+      const own = mark(born, "我来到这里");
+      if (own) out.push(own);
+    }
+    for (const row of this.db
+      .prepare(
+        "SELECT user_id,first_seen FROM mind_people WHERE first_seen<=? ORDER BY first_seen LIMIT 500",
+      )
+      .all(now)) {
+      if (out.length >= limit) break;
+      const person = this.mind.bonds.person(row.user_id, now);
+      if (!person || person.familiarity < 0.3) continue;
+      const label = mark(row.first_seen, `认识${person.name}`);
+      if (label) out.push(label);
+    }
+    return out.slice(0, limit);
+  }
+}

package/server/mind/evidence-read.js

@@ -0,0 +1,45 @@
+const states = new WeakMap();
+const LIMIT = 4096;
+
+// Provenance walks often visit the same ancestors from many threads. Reuse
+// their reads, while physical DB changes and the exact cutoff keep history,
+// revocations and other-process updates isolated.
+export function evidenceReader(db) {
+  let state = states.get(db);
+  if (!state) {
+    state = {
+      mark: db.prepare(
+        "SELECT total_changes() changes,(SELECT data_version FROM pragma_data_version) external",
+      ),
+      stamp: "",
+      statements: new Map(),
+      rows: new Map(),
+    };
+    states.set(db, state);
+  }
+  const mark = state.mark.get(),
+    stamp = `${mark.changes}:${mark.external}`,
+    transaction = db.isTransaction === true;
+  // total_changes includes rolled-back writes. Never retain reads from an
+  // explicit transaction, otherwise its abandoned data could survive rollback.
+  if (transaction || stamp !== state.stamp) {
+    state.rows.clear();
+    state.stamp = stamp;
+  }
+  return (sql, args = [], many = false) => {
+    let query = state.statements.get(sql);
+    if (!query) {
+      query = { id: state.statements.size, statement: db.prepare(sql) };
+      state.statements.set(sql, query);
+    }
+    const key = JSON.stringify([query.id, many, args]);
+    if (!transaction && state.rows.has(key)) return state.rows.get(key);
+    const row = query.statement[many ? "all" : "get"](...args);
+    if (!transaction) {
+      state.rows.set(key, row);
+      if (state.rows.size > LIMIT)
+        state.rows.delete(state.rows.keys().next().value);
+    }
+    return row;
+  };
+}

package/server/mind/evidence.js

@@ -0,0 +1,148 @@
+import { evidence, parse } from "./util.js";
+import { evidenceReader } from "./evidence-read.js";
+
+// A retelling is an interpretation of an experience, not another experience.
+// Resolve all derivative citations to the same roots, without writing history.
+export function evidenceRoots(
+  db,
+  sources,
+  before = Number.MAX_SAFE_INTEGER,
+  { includeDerived = false } = {},
+) {
+  const queue = [...evidence(sources)];
+  const visited = new Set();
+  const roots = new Set();
+  const read = evidenceReader(db);
+  for (let cursor = 0; cursor < queue.length; cursor++) {
+    if (visited.size >= 2048) return []; // Fail closed on damaged/unbounded graphs.
+    const ref = queue[cursor];
+    if (visited.has(ref)) continue;
+    visited.add(ref);
+    const kind = ref[0],
+      id = ref.slice(2);
+    if (["m", "r", "f"].includes(kind)) {
+      if (kind === "m") {
+        const event = read(
+            "SELECT time,CASE WHEN json_valid(payload) THEN json_extract(payload,'$.artifact.workId') END work_id FROM core_events WHERE seq=?",
+            [Number(id)],
+          ),
+          workId = event?.time <= before ? event.work_id : null;
+        if (workId) {
+          const work = read("SELECT task_id FROM mind_time_works WHERE id=?", [
+            workId,
+          ]);
+          if (work?.task_id) {
+            queue.push(`x:${work.task_id}`);
+            continue;
+          }
+        }
+      }
+      roots.add(ref);
+      continue;
+    }
+    if (kind === "o" || kind === "e") {
+      const row =
+        kind === "o"
+          ? read(
+              "SELECT created FROM mind_observations WHERE id=? AND revoked=0",
+              [id],
+            )
+          : read(
+              "SELECT finished AS created FROM mind_actions WHERE id=? AND state='done'",
+              [id],
+            );
+      if (row && row.created <= before) roots.add(ref);
+      continue;
+    }
+    let rows = [];
+    if (kind === "x") {
+      rows = read(
+        "SELECT sources,created,(SELECT MIN(v.created) FROM mind_time_versions v JOIN mind_time_works w ON w.id=v.work_id WHERE w.task_id=mind_time_tasks.id) first_version FROM mind_time_tasks WHERE id=?",
+        [id],
+        true,
+      ).filter(
+        (row) =>
+          row.created <= before &&
+          row.first_version !== null &&
+          row.first_version <= before,
+      );
+      if (rows.length) roots.add(ref);
+    } else if (kind === "t")
+      rows = read(
+        "SELECT sources,parent_id,created FROM mind_thoughts WHERE id=? AND hidden=0",
+        [id],
+        true,
+      );
+    else if (kind === "d")
+      rows = read(
+        "SELECT sources,created FROM mind_diary WHERE day=?",
+        [id],
+        true,
+      );
+    else if (kind === "s")
+      rows = read(
+        "SELECT sources,created FROM mind_self WHERE thread=? AND thread NOT IN (SELECT target_id FROM mind_revocations WHERE target_kind='self')",
+        [id],
+        true,
+      );
+    else if (kind === "g")
+      rows = read(
+        "SELECT sources,created FROM mind_meetings WHERE id=? AND id NOT IN (SELECT target_id FROM mind_revocations WHERE target_kind='meeting')",
+        [id],
+        true,
+      );
+    else if (kind === "a")
+      rows = read(
+        "SELECT sources,created FROM mind_anticipations WHERE id=?",
+        [id],
+        true,
+      );
+    rows = rows.filter((row) => row.created <= before);
+    // A self-originated wish is one stable internal source. Retelling it
+    // must not mint another one; it is distinguishable from external roots.
+    if (
+      kind === "s" &&
+      rows.length &&
+      rows.some((row) => !evidence(parse(row.sources, [])).length)
+    )
+      roots.add(ref);
+    for (const row of rows) {
+      queue.push(...evidence(parse(row.sources, [])));
+      if (row.parent_id) queue.push(`t:${row.parent_id}`);
+    }
+  }
+  return [...new Set([...roots, ...(includeDerived ? visited : [])])];
+}
+
+// Evidence outside the model's own wording. Unsent drafts, simulations,
+// unknown citations and new names for an internal wish do not qualify.
+export function externalEvidence(db, sources, before) {
+  return evidenceRoots(db, sources, before).filter((ref) => {
+    const id = ref.slice(2);
+    if (ref.startsWith("x:"))
+      return !!db
+        .prepare(
+          "SELECT 1 FROM mind_time_tasks WHERE id=? AND state!='abandoned' AND created<=? AND EXISTS(SELECT 1 FROM mind_time_versions v JOIN mind_time_works w ON w.id=v.work_id WHERE w.task_id=mind_time_tasks.id AND v.created<=? AND length(v.content)>0) AND (SELECT COALESCE(SUM(active_ms),0) FROM mind_time_spans WHERE task_id=mind_time_tasks.id AND updated<=?)>=300000",
+        )
+        .get(id, before, before, before);
+    if (ref.startsWith("m:"))
+      return !!db
+        .prepare(
+          "SELECT 1 FROM core_events WHERE seq=? AND time<=? AND role='user' AND COALESCE(json_extract(payload,'$.simulated'),0)=0 AND seq NOT IN (SELECT seq FROM mind_unlived)",
+        )
+        .get(Number(id), before);
+    if (ref.startsWith("f:"))
+      return !!db
+        .prepare(
+          "SELECT 1 FROM reply_feedback f JOIN decisions d ON d.id=f.decision_id WHERE f.decision_id=? AND f.time<=? AND d.is_demo=0",
+        )
+        .get(id, before);
+    if (ref.startsWith("r:"))
+      return !!db
+        .prepare(
+          "SELECT 1 FROM mind_readings WHERE chunk_id=? AND created<=? LIMIT 1",
+        )
+        .get(id, before);
+    return false;
+  });
+}

package/server/mind/faces.js

@@ -0,0 +1,138 @@
+import { randomUUID } from "node:crypto";
+import { evidenceRoots } from "./evidence.js";
+import { evidence, hasCredential, 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 class Faces {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  revoked() {
+    return new Set(
+      this.db
+        .prepare(
+          "SELECT target_id FROM mind_revocations WHERE target_kind='face'",
+        )
+        .all()
+        .map((row) => row.target_id),
+    );
+  }
+  history(session, limit = 30) {
+    const revoked = this.revoked();
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_faces WHERE session_id=? ORDER BY created DESC, rowid DESC LIMIT ?",
+      )
+      .all(session, limit)
+      .map((row) => ({
+        ...row,
+        sources: JSON.parse(row.sources),
+        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
+    );
+  }
+  all(before = Number.MAX_SAFE_INTEGER) {
+    return this.db
+      .prepare("SELECT DISTINCT session_id FROM mind_faces WHERE created<=?")
+      .all(before)
+      .map((row) => this.current(row.session_id, before))
+      .filter(Boolean);
+  }
+  propose(
+    input,
+    { valid = null, origin = "solitude", time = Date.now() } = {},
+  ) {
+    const session = String(input?.session || "");
+    if (!this.db.prepare("SELECT 1 FROM sessions WHERE id=?").get(session))
+      return { rejected: "会话不存在" };
+    const next = {
+      role: text(input.role, 40),
+      tone: text(input.tone, 60),
+      aspiration: text(input.aspiration, 80),
+      content: text(input.content, 300),
+    };
+    if (!Object.values(next).some(Boolean)) return { rejected: "空内容" };
+    if (hasCredential(Object.values(next).join(" ")))
+      return { rejected: "疑似凭据" };
+    if (session.includes(":group:") || session.startsWith("group:"))
+      if (!this.mind.meetings.sayable(Object.values(next).join(" "), session))
+        return { rejected: "不能把私下说法写进群里的面貌" };
+    const cited = evidence(input.sources);
+    const sources = valid ? cited.filter((s) => valid.has(s)) : cited;
+    if (!sources.length && origin !== "migration")
+      return { rejected: "缺少来源" };
+    const roots = this.mind.meetings.privateRoots(sources);
+    if (roots.length && !roots.includes(session))
+      return { rejected: "来源不能带到这个会话" };
+    const spent = new Set();
+    for (const row of this.db
+      .prepare("SELECT sources FROM mind_faces WHERE session_id=?")
+      .all(session))
+      for (const source of evidenceRoots(
+        this.db,
+        JSON.parse(row.sources || "[]"),
+        time,
+      ))
+        spent.add(source);
+    if (
+      sources.length &&
+      !evidenceRoots(this.db, sources, time).some(
+        (source) => !spent.has(source),
+      )
+    )
+      return { rejected: "没有新的经历" };
+    const current = this.current(session, time);
+    if (current) {
+      for (const key of Object.keys(next))
+        if (!next[key]) next[key] = current[key];
+      if (
+        Object.keys(next).every((key) =>
+          next[key] ? similar(next[key], current[key], 0.85) : !current[key],
+        )
+      )
+        return { rejected: "没有变化" };
+    }
+    const id = randomUUID();
+    this.db
+      .prepare(
+        "INSERT INTO mind_faces(id,session_id,created,role,tone,aspiration,content,sources,origin) VALUES (?,?,?,?,?,?,?,?,?)",
+      )
+      .run(
+        id,
+        session,
+        time,
+        next.role,
+        next.tone,
+        next.aspiration,
+        next.content,
+        JSON.stringify(sources),
+        origin,
+      );
+    return { id };
+  }
+}
+
+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)
+    .join("；")
+    .slice(0, 360);
+}

package/server/mind/guard.js

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