luckytri 1.0.0

package/server/mind/self.js

@@ -0,0 +1,484 @@
+import { randomUUID } from "node:crypto";
+import { evidenceRoots, externalEvidence } from "./evidence.js";
+import {
+  CORE_THREADS,
+  THREAD_FADED,
+  THREAD_FADING,
+  aboutLife,
+  anyTouches,
+  leftLife,
+  cueList,
+  echoes,
+  ownLife,
+  sameSelf,
+  threadSalience,
+} from "./salience.js";
+import { claimedPlay, leaks } from "./guard.js";
+import { isPrivateSession } from "./memory.js";
+import {
+  clamp,
+  dayKey,
+  evidence,
+  hasCredential,
+  messageSeqs,
+  parse,
+  similar,
+  text,
+} from "./util.js";
+
+export const SELF_KINDS = {
+  interest: "喜欢",
+  view: "看法",
+  trait: "特质",
+  habit: "习惯",
+  intention: "想做的事",
+  care: "放在心上",
+  curiosity: "好奇",
+};
+const STEP = 0.15;
+const NEW_CAP = 0.35;
+const TRAIT_CAP = 0.25;
+
+// Fade follows the last version that cited something not cited before.
+// The first version counts even when it has no source.
+function earnedAt(history, roots) {
+  if (!history?.length) return null;
+  const seen = new Set(roots(history[0].sources || []));
+  let at = history[0].created;
+  for (const row of history.slice(1)) {
+    const sources = roots(row.sources || []);
+    if (sources.some((source) => !seen.has(source))) at = row.created;
+    for (const source of sources) seen.add(source);
+  }
+  return at;
+}
+// Likes, questions, and a small wish of her own can begin without a message.
+// Views, traits, habits, and cares still have to point at something that happened.
+const SELF_ORIGINATED = new Set(["interest", "curiosity", "intention"]);
+
+export class Self {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+    this.annotation = null;
+  }
+  revokedThreads() {
+    return new Set(
+      this.db
+        .prepare(
+          "SELECT target_id FROM mind_revocations WHERE target_kind='self'",
+        )
+        .all()
+        .map((row) => row.target_id),
+    );
+  }
+  revokedContents() {
+    return this.db
+      .prepare("SELECT content FROM mind_revocations WHERE target_kind='self'")
+      .all()
+      .map((row) => row.content)
+      .filter(Boolean);
+  }
+  latest(before = Number.MAX_SAFE_INTEGER) {
+    const revoked = this.revokedThreads();
+    return this.db
+      .prepare(
+        `SELECT s.* FROM mind_self s WHERE s.rowid=(
+           SELECT t.rowid FROM mind_self t WHERE t.thread=s.thread AND t.created<=?
+           ORDER BY t.created DESC, t.rowid DESC LIMIT 1)`,
+      )
+      .all(before)
+      .filter((row) => !revoked.has(row.thread))
+      .map((row) => ({
+        ...row,
+        sources: parse(row.sources, []),
+        days: parse(row.days, []),
+      }));
+  }
+  // Every open thread with how present it is at `now`. The strongest few are
+  // her core and never fall out of view.
+  annotated({ before = Number.MAX_SAFE_INTEGER, now } = {}) {
+    const at = now ?? (before < Number.MAX_SAFE_INTEGER ? before : Date.now());
+    const mark = this.db
+      .prepare(
+        "SELECT total_changes() changes, (SELECT data_version FROM pragma_data_version) external",
+      )
+      .get();
+    const key = `${before}:${at}:${mark.changes}:${mark.external}`;
+    if (this.annotation?.key === key)
+      return structuredClone(this.annotation.rows);
+    const lived = this.mind.days.lived(at);
+    const versions = new Map();
+    for (const row of this.db
+      .prepare(
+        "SELECT thread, created, sources FROM mind_self WHERE created<=? ORDER BY created, rowid",
+      )
+      .all(before)) {
+      const list = versions.get(row.thread) || [];
+      list.push({ created: row.created, sources: parse(row.sources, []) });
+      versions.set(row.thread, list);
+    }
+    const notes = this.#lifeNotes(before);
+    const rows = this.latest(before)
+      // The record stays, but a claim to have played what she never played is
+      // not handed back to her as who she is.
+      .filter((row) => row.status !== "closed" && !claimedPlay(row.content))
+      .map((row) => {
+        // A rewording is not a new meeting with the thread. Fade follows the
+        // last version that actually brought new evidence. A later note she
+        // wrote to herself, a meeting that met this wish, words she spoke
+        // about it, or a line she later sent about it, are also living it.
+        let at =
+          earnedAt(versions.get(row.thread), (sources) =>
+            evidenceRoots(this.db, sources, before),
+          ) ?? row.created;
+        if (row.kind === "intention" && ownLife(row.content)) {
+          for (const note of notes)
+            if (
+              note.created > at &&
+              aboutLife(row.content, note.content) &&
+              !leftLife(row.content, note.content)
+            )
+              at = note.created;
+          const metAt = this.mind.meetings.livedAt(row.thread, before);
+          if (metAt != null && metAt > at) at = metAt;
+        }
+        return {
+          ...row,
+          salience: threadSalience({ ...row, created: at }, lived),
+        };
+      });
+    // One core seat belongs to the wish she is living. Stronger duties
+    // keep the remaining seats; they do not fade her own life out of view.
+    const reserved = this.#preferLived(
+      rows.filter((row) => row.kind === "intention" && ownLife(row.content)),
+      at,
+    );
+    const rest = rows
+      .filter((row) => row.thread !== reserved?.thread)
+      .sort((a, b) => b.strength - a.strength || b.created - a.created);
+    const core = new Set(
+      [reserved, ...rest.slice(0, CORE_THREADS - (reserved ? 1 : 0))]
+        .filter(Boolean)
+        .map((row) => row.thread),
+    );
+    const ranked = rows
+      .map((row) => ({
+        ...row,
+        core: core.has(row.thread),
+        faded: !core.has(row.thread) && row.salience < THREAD_FADED,
+      }))
+      .sort((a, b) => b.salience - a.salience || b.created - a.created);
+    // Several views in one read use the same exact moment, never a later replay.
+    // Writes and external database changes invalidate the derived picture.
+    this.annotation = { key, rows: ranked };
+    return structuredClone(ranked);
+  }
+  // The one wish she is living. In a room, a stronger wish that does not
+  // belong there does not erase the next wish that does. A duty about
+  // how she will treat someone stays a thread; it does not take this seat
+  // or the core place that keeps this wish from fading first.
+  living({ before = Number.MAX_SAFE_INTEGER, now, room } = {}) {
+    const at = now ?? (before < Number.MAX_SAFE_INTEGER ? before : Date.now());
+    return this.#preferLived(
+      this.annotated({ before, now: at }).filter(
+        (row) =>
+          row.kind === "intention" &&
+          !row.faded &&
+          ownLife(row.content) &&
+          (room === undefined || this.mind.meetings.stays(row, room)),
+      ),
+      at,
+    );
+  }
+  // Among her own wishes, the one her latest note or spoken line is about.
+  // A later send or answer about another wish takes this seat from an
+  // earlier note. A line that puts a wish down does not keep that seat;
+  // older notes about the put-down wish do not take it back. Planned
+  // drafts and silent meetings do not. No such line: the one still most
+  // present. Duties never enter this list.
+  #preferLived(candidates, now) {
+    if (!candidates.length) return null;
+    const notes = this.mind.thoughts
+      .open({ now, limit: 8 })
+      .filter((t) => t.kind === "expression" || t.kind === "unfinished");
+    const lines = this.mind.meetings.recentSaid(now, 8);
+    for (const note of notes) {
+      if (note.outreach_status === "sent" && note.outreach)
+        lines.push({
+          text: note.outreach,
+          at: note.outreach_at ?? note.created,
+          spoken: true,
+        });
+      lines.push({ text: note.content, at: note.created, spoken: false });
+    }
+    lines.sort((a, b) => b.at - a.at || Number(b.spoken) - Number(a.spoken));
+    const dropped = new Set();
+    for (const line of lines) {
+      for (const row of candidates)
+        if (!dropped.has(row.thread) && leftLife(row.content, line.text))
+          dropped.add(row.thread);
+      const held = candidates.filter(
+        (row) =>
+          !dropped.has(row.thread) &&
+          aboutLife(row.content, line.text) &&
+          !leftLife(row.content, line.text),
+      );
+      if (held.length)
+        return [...held].sort(
+          (a, b) => b.salience - a.salience || b.created - a.created,
+        )[0];
+    }
+    const remain = candidates.filter((row) => !dropped.has(row.thread));
+    if (!remain.length) return null;
+    return [...remain].sort(
+      (a, b) => b.salience - a.salience || b.created - a.created,
+    )[0];
+  }
+  // Notes she wrote to herself. Hidden ones do not count; resolved ones
+  // still do, because she did think them.
+  #lifeNotes(before) {
+    return this.db
+      .prepare(
+        `SELECT created, content FROM mind_thoughts
+         WHERE created<=? AND kind IN ('expression','unfinished') AND hidden=0`,
+      )
+      .all(before);
+  }
+  // Open threads that are the same wish as this one, including itself.
+  // History stays split; reading treats them as one life.
+  sameThreads(row, { before = Number.MAX_SAFE_INTEGER } = {}) {
+    if (!row?.thread) return [];
+    const kind = row.kind || "intention";
+    const content = row.content || "";
+    return this.latest(before).filter(
+      (other) =>
+        other.status !== "closed" &&
+        other.kind === kind &&
+        (other.thread === row.thread ||
+          (content && sameSelf(other.content, content))),
+    );
+  }
+  active({ before, limit = 40, now } = {}) {
+    const ranked = this.annotated({ before, now }).filter((row) => !row.faded);
+    const picked = ranked.filter((row) => row.core).slice(0, limit);
+    for (const row of ranked) {
+      if (picked.length >= limit) break;
+      if (!row.core) picked.push(row);
+    }
+    return picked.sort(
+      (a, b) => b.salience - a.salience || b.created - a.created,
+    );
+  }
+  dormant({ before, now } = {}) {
+    return this.annotated({ before, now }).filter((row) => row.faded);
+  }
+  // Faded threads that what is being said right now brings back to mind.
+  reminded({ before, now, cue, cues, limit = 2 } = {}) {
+    const sets = cueList(cue, cues);
+    if (!sets.length) return [];
+    return this.dormant({ before, now })
+      .filter((row) => anyTouches(row.content, sets))
+      .sort((a, b) => b.strength - a.strength)
+      .slice(0, limit);
+  }
+  // Threads slipping out of view, for her to let go of or find again.
+  fading({ before, now, limit = 3 } = {}) {
+    return this.annotated({ before, now })
+      .filter(
+        (row) =>
+          !row.core && row.salience < THREAD_FADING && row.salience >= 0.04,
+      )
+      .sort((a, b) => b.strength - a.strength)
+      .slice(0, limit);
+  }
+  history(thread) {
+    return this.db
+      .prepare("SELECT * FROM mind_self WHERE thread=? ORDER BY created")
+      .all(thread)
+      .map((row) => ({
+        ...row,
+        sources: parse(row.sources, []),
+        days: parse(row.days, []),
+      }));
+  }
+  days(sources, time, { external = false } = {}) {
+    const timeZone = this.mind.timeZone();
+    const seqs = messageSeqs(
+      external
+        ? externalEvidence(this.db, sources, time)
+        : evidenceRoots(this.db, sources, time),
+    );
+    const found = seqs.length
+      ? this.db
+          .prepare(
+            `SELECT time FROM core_events WHERE seq IN (${seqs.map(() => "?").join(",")})`,
+          )
+          .all(...seqs)
+          .map((row) => dayKey(row.time, timeZone))
+      : [];
+    // Diary days cited in a review count as the days it happened.
+    // A diary written later does not make its underlying experience later.
+    return [
+      ...new Set(
+        found.length ? found : external ? [] : [dayKey(time, timeZone)],
+      ),
+    ];
+  }
+  propose(
+    input,
+    { valid = null, origin = "solitude", time = Date.now() } = {},
+  ) {
+    const kind = SELF_KINDS[input?.kind] ? input.kind : null;
+    const content = text(input?.content, 160);
+    let action = ["new", "revise", "close"].includes(input?.action)
+      ? input.action
+      : input?.thread
+        ? "revise"
+        : "new";
+    if (!content && action !== "close") return { rejected: "空内容" };
+    if (hasCredential(content)) return { rejected: "疑似凭据" };
+    // What she said to fit in is not a life she has lived.
+    if (action !== "close" && claimedPlay(content))
+      return { rejected: "没有玩过的经历，不能写成她的样子" };
+    const cited = evidence(input?.sources);
+    const sources = valid ? cited.filter((s) => valid.has(s)) : cited;
+    if (cited.length && !sources.length)
+      return { rejected: "来源不在本次经历中" };
+    // Memory consolidation only records what she herself said. A wish with
+    // no message is hers to form in solitude, not for the summarizer to add.
+    if (origin === "memory" && !sources.length) return { rejected: "缺少来源" };
+    if (
+      content &&
+      this.revokedContents().some((old) => similar(old, content, 0.7))
+    )
+      return { rejected: "与撤销过的内容相同" };
+    // Faded threads count too: touching one again brings it back instead of
+    // growing a second copy of it.
+    const current = this.latest(time).filter((row) => row.status !== "closed");
+    let prior = null;
+    if (action === "new") {
+      if (!kind) return { rejected: "类型无效" };
+      prior = current.find(
+        (row) => row.kind === kind && sameSelf(row.content, content),
+      );
+      if (prior) action = "revise";
+      else if (!sources.length && !SELF_ORIGINATED.has(kind))
+        return { rejected: "缺少来源" };
+    } else {
+      prior = this.latest(time).find((row) => row.thread === input.thread);
+      if (!prior) return { rejected: "线索不存在或已撤销" };
+    }
+    const spent = new Set();
+    if (prior)
+      for (const row of this.history(prior.thread))
+        for (const source of evidenceRoots(this.db, row.sources || [], time))
+          spent.add(source);
+    let fresh = sources.filter((source) =>
+      evidenceRoots(this.db, [source], time).some((root) => !spent.has(root)),
+    );
+    const lasting = ["trait", "habit"].includes(prior?.kind || kind);
+    const freshWords = fresh;
+    if (lasting)
+      fresh = fresh.filter((source) =>
+        externalEvidence(this.db, [source], time).some(
+          (root) => !spent.has(root),
+        ),
+      );
+    const spoken = content || prior?.content || "";
+    // The same evidence cannot be spent again to make a thread stronger.
+    // An unchanged sentence is not a new version. A rewording can stay,
+    // at the strength the earlier evidence already earned.
+    if (
+      prior &&
+      action !== "close" &&
+      !fresh.length &&
+      (spoken === prior.content || origin === "memory")
+    )
+      return { rejected: "没有新的经历" };
+    // Citing her message is not enough. The words kept have to be hers.
+    if (
+      origin === "memory" &&
+      action !== "close" &&
+      !echoes(spoken, this.#spoken(freshWords))
+    )
+      return { rejected: "对不上她说过的话" };
+    // A revision that cites nothing new keeps the old provenance. Dropping
+    // it would let a privately learned sentence travel into other rooms.
+    const kept = [
+      ...new Set([
+        ...(prior && !fresh.length ? prior.sources || [] : []),
+        ...sources,
+      ]),
+    ];
+    const days = [
+      ...new Set([
+        ...(prior?.days || []),
+        ...this.days(kept, time, { external: lasting }),
+      ]),
+    ].slice(-60);
+    let strength;
+    let status;
+    if (action === "close") {
+      strength = prior.strength;
+      status = "closed";
+    } else if (prior) {
+      const wanted = fresh.length
+        ? Number.isFinite(Number(input?.strength))
+          ? clamp(input.strength)
+          : prior.strength + 0.05
+        : prior.strength;
+      strength = fresh.length
+        ? clamp(prior.strength + clamp(wanted - prior.strength, -STEP, STEP))
+        : prior.strength;
+      status =
+        prior.kind === "trait" && (days.length < 2 || strength < 0.35)
+          ? "emerging"
+          : "active";
+    } else {
+      strength = Math.min(
+        kind === "trait" ? TRAIT_CAP : NEW_CAP,
+        clamp(input?.strength ?? 0.25),
+      );
+      status = kind === "trait" ? "emerging" : "active";
+    }
+    const id = randomUUID();
+    const home = this.#home(spoken, input?.session);
+    this.db
+      .prepare(
+        "INSERT INTO mind_self(id,thread,created,kind,content,strength,status,sources,days,origin,session_id) VALUES (?,?,?,?,?,?,?,?,?,?,?)",
+      )
+      .run(
+        id,
+        prior?.thread || id,
+        time,
+        prior?.kind || kind,
+        spoken,
+        Math.round(strength * 100) / 100,
+        status,
+        JSON.stringify(kept),
+        JSON.stringify(days),
+        origin,
+        home,
+      );
+    return { id, thread: prior?.thread || id, action };
+  }
+  // Wording that matches something she learned in private stays in that room,
+  // even when she did not cite a source.
+  #home(content, requested) {
+    const hit = leaks([content], this.mind.meetings.privateSayings())[0];
+    if (hit?.session_id) return hit.session_id;
+    return isPrivateSession(requested) ? requested : null;
+  }
+  #spoken(sources) {
+    const seqs = messageSeqs(sources);
+    if (!seqs.length) return [];
+    return this.db
+      .prepare(
+        `SELECT role, payload FROM core_events WHERE seq IN (${seqs.map(() => "?").join(",")})`,
+      )
+      .all(...seqs)
+      .filter((row) => row.role === "assistant")
+      .map((row) => parse(row.payload, {}).text || "");
+  }
+}

package/server/mind/senses.js

@@ -0,0 +1,53 @@
+import { text } from "./util.js";
+
+const LIMIT = 4;
+const LINE = 80;
+
+// What the world is telling her right now: weather, a song, a room.
+// Kept in memory, never written into who she is. A private line stays out of
+// group conversations.
+export class Senses {
+  constructor() {
+    this.rows = new Map();
+  }
+  set(pluginId, key, sense, now = Date.now()) {
+    const id = `${pluginId}:${String(key || "now").slice(0, 40)}`;
+    const line = text(sense?.text, LINE);
+    if (!line) {
+      this.rows.delete(id);
+      return;
+    }
+    const ttl = Number(sense?.ttlMinutes);
+    this.rows.set(id, {
+      pluginId,
+      text: line,
+      discretion: sense?.discretion === "private" ? "private" : "open",
+      until:
+        Number.isFinite(ttl) && ttl > 0 ? now + Math.min(ttl, 1440) * 60000 : 0,
+    });
+  }
+  clear(pluginId, key) {
+    if (key == null) {
+      for (const [id, row] of this.rows)
+        if (row.pluginId === pluginId) this.rows.delete(id);
+      return;
+    }
+    this.rows.delete(`${pluginId}:${String(key).slice(0, 40)}`);
+  }
+  clearPlugin(pluginId) {
+    this.clear(pluginId, null);
+  }
+  lines({ kind = "group", now = Date.now() } = {}) {
+    const out = [];
+    for (const [id, row] of this.rows) {
+      if (row.until && row.until <= now) {
+        this.rows.delete(id);
+        continue;
+      }
+      if (kind === "group" && row.discretion === "private") continue;
+      out.push(row.text);
+      if (out.length >= LIMIT) break;
+    }
+    return out;
+  }
+}