luckytri 1.0.9 → 1.1.0

package/server/mind/recall/schema.js

@@ -0,0 +1,132 @@
+import { recallTokens } from "./store.js";
+
+// The recall index is derived: every row can be rebuilt from the tables that
+// hold her actual memories, so it may be dropped and refilled at any time.
+// Episodes are memories in their own right and follow the append-only rule:
+// a later state of the same affair is a new row in the same thread.
+export function migrateRecall(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS mind_index(
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      ref TEXT NOT NULL,
+      session_id TEXT,
+      discretion TEXT NOT NULL DEFAULT 'open',
+      basis TEXT NOT NULL DEFAULT 'stated',
+      status TEXT NOT NULL DEFAULT 'active',
+      happened INTEGER NOT NULL,
+      updated INTEGER NOT NULL,
+      weight REAL NOT NULL DEFAULT 0.5,
+      text TEXT NOT NULL,
+      text_hash TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS mind_index_kind ON mind_index(kind,status,happened);
+    CREATE INDEX IF NOT EXISTS mind_index_ref ON mind_index(kind,ref);
+    CREATE TABLE IF NOT EXISTS mind_index_people(
+      item_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      PRIMARY KEY(item_id,user_id)
+    );
+    CREATE INDEX IF NOT EXISTS mind_index_people_user ON mind_index_people(user_id,item_id);
+    CREATE TABLE IF NOT EXISTS mind_vectors(
+      item_id TEXT NOT NULL,
+      profile TEXT NOT NULL,
+      text_hash TEXT NOT NULL,
+      dim INTEGER NOT NULL,
+      vector BLOB NOT NULL,
+      created INTEGER NOT NULL,
+      PRIMARY KEY(item_id,profile)
+    );
+    CREATE INDEX IF NOT EXISTS mind_vectors_profile ON mind_vectors(profile);
+    CREATE TABLE IF NOT EXISTS mind_episodes(
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      created INTEGER NOT NULL,
+      session_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      outcome TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'open',
+      participants TEXT NOT NULL DEFAULT '[]',
+      happened_start INTEGER,
+      happened_end INTEGER,
+      follow_up_at INTEGER,
+      basis TEXT NOT NULL DEFAULT 'witnessed',
+      importance REAL NOT NULL DEFAULT 0.5,
+      discretion TEXT NOT NULL DEFAULT 'open',
+      sources TEXT NOT NULL DEFAULT '[]',
+      run_id TEXT
+    );
+    CREATE INDEX IF NOT EXISTS mind_episodes_thread ON mind_episodes(thread_id,created);
+    CREATE INDEX IF NOT EXISTS mind_episodes_time ON mind_episodes(created);
+    -- How two memories relate: an episode continues or resolves another, a
+    -- fact may conflict with an older one, two events may be alike. Ends
+    -- are index ids such as "episode:ID" or "fact:ID". "similar" is only a
+    -- resemblance found by meaning; it never asserts that either is true.
+    CREATE TABLE IF NOT EXISTS mind_links(
+      from_id TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      created INTEGER NOT NULL,
+      sources TEXT NOT NULL DEFAULT '[]',
+      PRIMARY KEY(from_id,to_id,relation)
+    );
+    CREATE INDEX IF NOT EXISTS mind_links_to ON mind_links(to_id,relation);
+    -- How the turn read a message it answered: in earnest or as a joke, a
+    -- fact or a guess. Consolidation uses it so a joke is not filed as fact.
+    CREATE TABLE IF NOT EXISTS core_message_cues(
+      seq INTEGER PRIMARY KEY,
+      tone TEXT,
+      stance TEXT,
+      trace_id TEXT,
+      created INTEGER NOT NULL
+    );
+  `);
+  db.exec(
+    "CREATE VIRTUAL TABLE IF NOT EXISTS mind_index_fts USING fts5(item_id UNINDEXED, tokens)",
+  );
+  // Keyword tokens moved to overlapping character pairs; rebuild once.
+  if (!db.prepare("SELECT 1 FROM core_config WHERE id='recall-fts-v2'").get()) {
+    db.exec("DELETE FROM mind_index_fts");
+    const insert = db.prepare(
+      "INSERT INTO mind_index_fts(item_id,tokens) VALUES (?,?)",
+    );
+    for (const row of db.prepare("SELECT id,text FROM mind_index").iterate()) {
+      const tokens = recallTokens(row.text);
+      if (tokens) insert.run(row.id, tokens);
+    }
+    db.prepare("INSERT INTO core_config(id,value) VALUES (?,?)").run(
+      "recall-fts-v2",
+      JSON.stringify({ time: Date.now() }),
+    );
+  }
+  const columns = new Set(
+    db
+      .prepare("PRAGMA table_info(core_memories)")
+      .all()
+      .map((c) => c.name),
+  );
+  // How a fact was learned, how often it was said again, and when last.
+  if (!columns.has("basis"))
+    db.exec(
+      "ALTER TABLE core_memories ADD COLUMN basis TEXT NOT NULL DEFAULT 'stated'",
+    );
+  if (!columns.has("evidence_count"))
+    db.exec(
+      "ALTER TABLE core_memories ADD COLUMN evidence_count INTEGER NOT NULL DEFAULT 1",
+    );
+  if (!columns.has("last_confirmed"))
+    db.exec("ALTER TABLE core_memories ADD COLUMN last_confirmed INTEGER");
+  if (
+    !db.prepare("SELECT 1 FROM core_config WHERE id='memory-basis-v1'").get()
+  ) {
+    db.exec(`UPDATE core_memories SET basis=CASE
+      WHEN type='inferred' OR sources LIKE '%"certainty":"inferred"%' THEN 'inferred'
+      WHEN type='hearsay' OR sources LIKE '%"certainty":"hearsay"%' THEN 'hearsay'
+      ELSE 'stated' END`);
+    db.prepare("INSERT INTO core_config(id,value) VALUES (?,?)").run(
+      "memory-basis-v1",
+      JSON.stringify({ time: Date.now() }),
+    );
+  }
+}

package/server/mind/recall/sources.js

@@ -0,0 +1,220 @@
+import { parse, text } from "../util.js";
+
+// How each kind of memory becomes one searchable item. The text is what the
+// item is about, written the way it would be recalled; people are the users it
+// concerns; discretion and session say where it may surface.
+const MAX_TEXT = 600;
+const revoked = (kind) =>
+  `SELECT target_id FROM mind_revocations WHERE target_kind='${kind}'`;
+
+function item(kind, ref, fields) {
+  return {
+    id: `${kind}:${ref}`,
+    kind,
+    ref: String(ref),
+    session_id: fields.session_id ?? null,
+    discretion: fields.discretion || "open",
+    basis: fields.basis || "stated",
+    status: fields.status || "active",
+    happened: Number(fields.happened) || 0,
+    updated: Number(fields.updated ?? fields.happened) || 0,
+    weight: Number.isFinite(Number(fields.weight))
+      ? Number(fields.weight)
+      : 0.5,
+    text: text(fields.text, MAX_TEXT),
+    people: [...new Set((fields.people || []).map(String).filter(Boolean))],
+  };
+}
+
+const FACT_STATUS = {
+  confirmed: "active",
+  superseded: "superseded",
+  candidate: "candidate",
+  archived: "archived",
+};
+
+export const SOURCES = {
+  fact: {
+    changed: "updated",
+    select:
+      "SELECT id,session_id,subject,content,importance,status,discretion,basis,created,updated FROM core_memories WHERE status!='deleted'",
+    one: "SELECT id,session_id,subject,content,importance,status,discretion,basis,created,updated FROM core_memories WHERE id=? AND status!='deleted'",
+    map: (row) =>
+      item("fact", row.id, {
+        session_id: row.session_id,
+        discretion: row.discretion,
+        basis: row.basis,
+        status: FACT_STATUS[row.status] || "candidate",
+        happened: row.created,
+        updated: row.updated,
+        weight: row.importance,
+        text: row.content,
+        people: [row.subject],
+      }),
+  },
+  meeting: {
+    changed: "created",
+    select: `SELECT m.*,(SELECT group_concat(user_id) FROM mind_meeting_people p WHERE p.meeting_id=m.id) who
+      FROM mind_meetings m WHERE (m.appraisal!='' OR m.exchange!='null') AND m.id NOT IN (${revoked("meeting")})`,
+    one: `SELECT m.*,(SELECT group_concat(user_id) FROM mind_meeting_people p WHERE p.meeting_id=m.id) who
+      FROM mind_meetings m WHERE m.id=? AND (m.appraisal!='' OR m.exchange!='null') AND m.id NOT IN (${revoked("meeting")})`,
+    map: (row) => {
+      const exchange = parse(row.exchange, null);
+      const they = (exchange?.they || [])
+        .map((line) => text(line.text, 120))
+        .join(" / ");
+      const said = (exchange?.iSaid || []).map((l) => text(l, 120)).join(" / ");
+      return item("meeting", row.id, {
+        session_id: row.session_id,
+        discretion: row.discretion,
+        basis: "witnessed",
+        status: "active",
+        happened: row.created,
+        weight: row.choice === "silent" ? 0.3 : 0.45,
+        text: [
+          row.topic,
+          row.appraisal,
+          they && `对方说：${they}`,
+          said && `我说：${said}`,
+        ]
+          .filter(Boolean)
+          .join("。"),
+        people: String(row.who || "").split(","),
+      });
+    },
+  },
+  self: {
+    changed: "created",
+    select: `SELECT s.* FROM mind_self s JOIN (SELECT thread,MAX(created) last FROM mind_self GROUP BY thread) l
+      ON l.thread=s.thread AND l.last=s.created WHERE s.thread NOT IN (${revoked("self")})`,
+    one: `SELECT * FROM mind_self WHERE thread=? AND thread NOT IN (${revoked("self")}) ORDER BY created DESC LIMIT 1`,
+    map: (row) =>
+      item("self", row.thread, {
+        session_id: row.session_id,
+        basis: "self",
+        status: row.status === "closed" ? "closed" : "active",
+        happened: row.created,
+        weight: row.strength,
+        text: [row.content, row.subject].filter(Boolean).join(" "),
+        people: row.subject ? [String(row.subject)] : [],
+      }),
+  },
+  thought: {
+    changed: "MAX(created,COALESCE(resolved_at,0))",
+    select: "SELECT * FROM mind_thoughts WHERE hidden=0",
+    one: "SELECT * FROM mind_thoughts WHERE id=? AND hidden=0",
+    map: (row) =>
+      item("thought", row.id, {
+        session_id: parse(row.sessions, [])[0] || null,
+        basis: "self",
+        status: row.status === "open" ? "active" : "resolved",
+        happened: row.created,
+        updated: row.resolved_at || row.created,
+        weight: row.importance,
+        text: row.content,
+      }),
+  },
+  diary: {
+    changed: "created",
+    select: `SELECT d.* FROM mind_diary d JOIN (SELECT day,MAX(created) last FROM mind_diary GROUP BY day) l
+      ON l.day=d.day AND l.last=d.created`,
+    one: "SELECT * FROM mind_diary WHERE day=? ORDER BY created DESC LIMIT 1",
+    key: "day",
+    map: (row) =>
+      item("diary", row.day, {
+        basis: "self",
+        happened: row.created,
+        weight: 0.4,
+        text: `${row.day} 的日记：${row.content}`,
+      }),
+  },
+  period: {
+    changed: "created",
+    select: "SELECT * FROM mind_periods",
+    one: "SELECT * FROM mind_periods WHERE id=?",
+    map: (row) =>
+      item("period", row.id, {
+        basis: "self",
+        happened: row.period_end || row.created,
+        weight: 0.4,
+        text:
+          [row.title, row.content].filter(Boolean).join("：") || row.content,
+      }),
+  },
+  anticipation: {
+    changed: "MAX(created,COALESCE(closed_at,0))",
+    select: `SELECT * FROM mind_anticipations WHERE id NOT IN (${revoked("anticipation")})`,
+    one: `SELECT * FROM mind_anticipations WHERE id=? AND id NOT IN (${revoked("anticipation")})`,
+    map: (row) =>
+      item("anticipation", row.id, {
+        session_id: row.session_id,
+        discretion: row.discretion,
+        basis: row.kind === "promise" ? "self" : "stated",
+        status: row.status === "pending" ? "active" : row.status,
+        happened: row.created,
+        updated: row.closed_at || row.created,
+        weight: 0.6,
+        text: row.content,
+        people: [row.subject],
+      }),
+  },
+  episode: {
+    changed: "created",
+    select: "SELECT * FROM mind_episodes",
+    one: "SELECT * FROM mind_episodes WHERE id=?",
+    map: (row) =>
+      item("episode", row.id, {
+        session_id: row.session_id,
+        discretion: row.discretion,
+        basis: row.basis,
+        status: row.status,
+        happened: row.happened_start || row.created,
+        updated: row.created,
+        weight: row.importance,
+        text: [row.title, row.content, row.outcome && `结果：${row.outcome}`]
+          .filter(Boolean)
+          .join("。"),
+        people: parse(row.participants, []),
+      }),
+  },
+};
+
+// Raw messages are evidence, not memories: they are searchable for a month
+// so an older line of the same conversation can be found by meaning, then
+// leave the index. The window is measured from the newest event, not the
+// wall clock, so a replay or a test sees the same index.
+export const MESSAGE_DAYS = 30;
+const recent = `time>(SELECT MAX(time) FROM core_events)-${MESSAGE_DAYS * 86400000}`;
+SOURCES.message = {
+  changed: "time",
+  select: `SELECT seq,session_id,time,role,payload FROM core_events
+    WHERE role IN ('user','assistant') AND ${recent}
+    AND COALESCE(json_extract(payload,'$.simulated'),0)=0
+    AND json_extract(payload,'$.artifact') IS NULL
+    AND seq NOT IN (SELECT seq FROM mind_unlived)`,
+  one: `SELECT seq,session_id,time,role,payload FROM core_events
+    WHERE seq=? AND role IN ('user','assistant') AND ${recent}
+    AND COALESCE(json_extract(payload,'$.simulated'),0)=0
+    AND json_extract(payload,'$.artifact') IS NULL
+    AND seq NOT IN (SELECT seq FROM mind_unlived)`,
+  map: (row) => {
+    const message = parse(row.payload, {});
+    const words = String(message.text || "");
+    return item("message", row.seq, {
+      session_id: row.session_id,
+      discretion: /private/.test(row.session_id) ? "private" : "open",
+      basis: "witnessed",
+      happened: row.time,
+      weight: 0.3,
+      text:
+        /^\[(?:图片|表情|媒体)\]+$/.test(words) || words.length < 2
+          ? ""
+          : words,
+      people: row.role === "user" ? [message.userId] : [],
+    });
+  },
+};
+
+export const KINDS = Object.keys(SOURCES);
+// Kinds that are memories proper; raw messages are searched only on purpose.
+export const MEMORY_KINDS = KINDS.filter((kind) => kind !== "message");