luckytri 1.1.2 → 1.2.0

package/server/mind/recall/roots.js

@@ -0,0 +1,231 @@
+import { interestTerms } from "../attention.js";
+import { evidenceRoots } from "../evidence.js";
+import { SELF_KINDS } from "../self.js";
+import { parse, text } from "../util.js";
+import { fixedReplyHabit } from "../../core/conversation-grounding.js";
+
+// What each of her records ultimately rests on: the messages, observations
+// and finished work its sources resolve to. Derived from the sources she
+// already keeps, so it can be dropped and refilled at any time; it asserts
+// nothing new. Two records that rest on the same moment belong together.
+const KINDS = {
+  episode: {
+    pending: (
+      from,
+    ) => `SELECT id ref, created stamp, sources FROM ${from("mind_episodes")} e
+      WHERE NOT EXISTS (SELECT 1 FROM mind_rooted r WHERE r.item_id='episode:'||e.id) LIMIT ?`,
+    roots: (db, row) => evidenceRoots(db, parse(row.sources, [])),
+  },
+  thought: {
+    pending: (
+      from,
+    ) => `SELECT id ref, created*2+hidden stamp FROM ${from("mind_thoughts")} t
+      WHERE NOT EXISTS (SELECT 1 FROM mind_rooted r WHERE r.item_id='thought:'||t.id AND r.stamp=t.created*2+t.hidden) LIMIT ?`,
+    roots: (db, row) => evidenceRoots(db, [`t:${row.ref}`]),
+  },
+  anticipation: {
+    pending: (
+      from,
+    ) => `SELECT id ref, created stamp FROM ${from("mind_anticipations")} a
+      WHERE NOT EXISTS (SELECT 1 FROM mind_rooted r WHERE r.item_id='anticipation:'||a.id) LIMIT ?`,
+    roots: (db, row) => evidenceRoots(db, [`a:${row.ref}`]),
+  },
+  // A self thread grows new versions and a note or thread may be taken
+  // back; either changes the stamp (time doubled, plus one once revoked),
+  // so it is looked at again.
+  self: {
+    pending: (
+      from,
+    ) => `SELECT ref, stamp FROM (SELECT thread ref, MAX(created)*2+EXISTS(SELECT 1 FROM mind_revocations v WHERE v.target_kind='self' AND v.target_id=thread) stamp FROM mind_self WHERE thread IN (SELECT thread FROM ${from("mind_self")} y) GROUP BY thread) x
+      WHERE NOT EXISTS (SELECT 1 FROM mind_rooted r WHERE r.item_id='self:'||x.ref AND r.stamp=x.stamp) LIMIT ?`,
+    roots: (db, row) => evidenceRoots(db, [`s:${row.ref}`]),
+  },
+};
+
+export function migrateRoots(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS mind_roots(
+      item_id TEXT NOT NULL,
+      root TEXT NOT NULL,
+      PRIMARY KEY(item_id,root)
+    );
+    CREATE INDEX IF NOT EXISTS mind_roots_root ON mind_roots(root);
+    CREATE TABLE IF NOT EXISTS mind_rooted(
+      item_id TEXT PRIMARY KEY,
+      stamp INTEGER NOT NULL
+    );
+  `);
+}
+
+// Works through records not yet looked at, a page at a time. Idempotent.
+// `recent` only looks among the newest rows of each table, cheap enough for
+// a turn; the background pass looks at everything.
+export function fillRoots(db, limit = 500, { recent = 0 } = {}) {
+  const from = (table) =>
+    recent
+      ? `(SELECT * FROM ${table} ORDER BY rowid DESC LIMIT ${Math.floor(recent)})`
+      : table;
+  let done = 0;
+  const clear = db.prepare("DELETE FROM mind_roots WHERE item_id=?");
+  const put = db.prepare(
+    "INSERT OR IGNORE INTO mind_roots(item_id,root) VALUES (?,?)",
+  );
+  const mark = db.prepare(
+    "INSERT INTO mind_rooted(item_id,stamp) VALUES (?,?) ON CONFLICT(item_id) DO UPDATE SET stamp=excluded.stamp",
+  );
+  db.exec("SAVEPOINT mind_roots_fill");
+  try {
+    for (const [kind, spec] of Object.entries(KINDS)) {
+      if (done >= limit) break;
+      for (const row of db.prepare(spec.pending(from)).all(limit - done)) {
+        const id = `${kind}:${row.ref}`;
+        clear.run(id);
+        for (const root of spec.roots(db, row)) put.run(id, root);
+        mark.run(id, row.stamp);
+        done++;
+      }
+    }
+    db.exec("RELEASE mind_roots_fill");
+  } catch (error) {
+    db.exec("ROLLBACK TO mind_roots_fill");
+    db.exec("RELEASE mind_roots_fill");
+    throw error;
+  }
+  return done;
+}
+
+const LINE = 60;
+const ANTICIPATION_STATE = {
+  pending: "还没做",
+  done: "做了",
+  missed: "没做成",
+  let_go: "放下了",
+};
+
+// Her own notes, intentions and self threads that rest on the same moments
+// as an affair, and that speak of it (two shared words, one from its title,
+// or close in meaning when both have vectors). At most two short lines: the first and the latest of a
+// revised note ("当时想 / 后来想"), then an intention of hers, then a self
+// thread. Records already in front of her are left out. Each line carries
+// the index id it came from, for the record of what came to mind.
+export function mineFor(
+  mind,
+  steps,
+  { session, now = Date.now(), exclude = new Set(), close = () => false } = {},
+) {
+  const db = mind.db;
+  const ids = steps.map((s) => `episode:${s.id}`);
+  if (!ids.length) return [];
+  const marks = ids.map(() => "?").join(",");
+  const linked = db
+    .prepare(
+      `SELECT DISTINCT b.item_id id FROM mind_roots a JOIN mind_roots b ON b.root=a.root
+       WHERE a.item_id IN (${marks}) AND a.root NOT LIKE 's:%'
+       AND (b.item_id LIKE 'thought:%' OR b.item_id LIKE 'anticipation:%' OR b.item_id LIKE 'self:%')`,
+    )
+    .all(...ids)
+    .map((r) => r.id)
+    .filter((id) => !exclude.has(id));
+  if (!linked.length) return [];
+  const terms = interestTerms(
+    steps.map((s) => [s.title, s.content, s.outcome].join(" ")),
+  );
+  // One shared pair is too easy to come by ("最近", "晚上"); it counts only
+  // when it is in the affair's own title. Otherwise two, or close meaning.
+  const titled = interestTerms(steps.map((s) => s.title));
+  const speaks = (id, words) => {
+    const shared = [...interestTerms([words])].filter((t) => terms.has(t));
+    return (
+      shared.length >= 2 || shared.some((t) => titled.has(t)) || close(id, ids)
+    );
+  };
+  const fits = (words) =>
+    words && !fixedReplyHabit(words) && mind.meetings.sayable(words, session);
+  const lines = [];
+  // Notes: one revision chain at a time, told by its first and latest step.
+  const notes = new Map();
+  for (const id of linked.filter((x) => x.startsWith("thought:"))) {
+    const row = db
+      .prepare(
+        "SELECT * FROM mind_thoughts WHERE id=? AND hidden=0 AND created<=?",
+      )
+      .get(id.slice(8), now);
+    if (!row || !parse(row.sessions, []).includes(session)) continue;
+    if (!fits(row.content) || !speaks(id, row.content)) continue;
+    notes.set(row.id, row);
+  }
+  const chainOf = (row) => {
+    let head = row;
+    for (let seen = 0; head.parent_id && seen < 20; seen++) {
+      const up = db
+        .prepare("SELECT * FROM mind_thoughts WHERE id=? AND hidden=0")
+        .get(head.parent_id);
+      if (!up) break;
+      head = up;
+    }
+    let last = head;
+    for (let seen = 0; seen < 20; seen++) {
+      const down = db
+        .prepare(
+          "SELECT * FROM mind_thoughts WHERE parent_id=? AND hidden=0 AND created<=? ORDER BY created DESC LIMIT 1",
+        )
+        .get(last.id, now);
+      if (!down) break;
+      last = down;
+    }
+    return { head, last };
+  };
+  const chains = new Map();
+  for (const row of [...notes.values()].sort((a, b) => a.created - b.created)) {
+    const { head, last } = chainOf(row);
+    if (!chains.has(head.id)) chains.set(head.id, { head, last });
+  }
+  for (const { head, last } of chains.values()) {
+    if (lines.length >= 2) break;
+    if (exclude.has(`thought:${head.id}`)) continue;
+    lines.push({
+      id: `thought:${head.id}`,
+      text: `当时想：${text(head.content, LINE)}`,
+    });
+    if (
+      last.id !== head.id &&
+      lines.length < 2 &&
+      !exclude.has(`thought:${last.id}`) &&
+      fits(last.content)
+    )
+      lines.push({
+        id: `thought:${last.id}`,
+        text: `后来想：${text(last.content, LINE)}`,
+      });
+  }
+  // Her own intentions about it.
+  for (const id of linked.filter((x) => x.startsWith("anticipation:"))) {
+    if (lines.length >= 2) break;
+    const row = db
+      .prepare(
+        `SELECT * FROM mind_anticipations WHERE id=? AND created<=? AND kind IN ('promise','plan')
+         AND id NOT IN (SELECT target_id FROM mind_revocations WHERE target_kind='anticipation')`,
+      )
+      .get(id.slice(13), now);
+    if (!row || (row.discretion !== "open" && row.session_id !== session))
+      continue;
+    if (!fits(row.content) || !speaks(id, row.content)) continue;
+    lines.push({
+      id,
+      text: `我打算过：${text(row.content, LINE)}（${ANTICIPATION_STATE[row.status] || row.status}）`,
+    });
+  }
+  // A self thread that grew from it and is not already in view.
+  for (const id of linked.filter((x) => x.startsWith("self:"))) {
+    if (lines.length >= 2) break;
+    const row = mind.self
+      .latest(now)
+      .find((t) => t.thread === id.slice(5) && t.status !== "closed");
+    if (!row || !fits(row.content) || !speaks(id, row.content)) continue;
+    lines.push({
+      id,
+      text: `${SELF_KINDS[row.kind] || "自己"}：${text(row.content, LINE)}`,
+    });
+  }
+  return lines.slice(0, 2);
+}

package/server/mind/recall/schema.js

@@ -1,4 +1,5 @@
 import { recallTokens } from "./store.js";
+import { migrateRoots } from "./roots.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.
@@ -129,4 +130,5 @@ export function migrateRecall(db) {
       JSON.stringify({ time: Date.now() }),
     );
   }
+  migrateRoots(db);
 }

package/server/mind/recall/store.js

@@ -20,15 +20,42 @@ const fromBlob = (blob) => {
   );
 };
 
+const kindOf = (id) => String(id).slice(0, String(id).indexOf(":"));
+
 // The searchable shadow of her memories: one row per item, its words for
 // keyword search, its people for structured lookups, and vectors kept per
 // embedding profile. Vectors of the active profile are held in memory for
-// exact cosine search; at tens of thousands of items that is milliseconds.
+// exact cosine search, split by kind so a search for facts never walks a
+// month of messages. The memory copy is kept in step item by item: a new
+// message, a rewritten fact or a removed item touches only its own entry.
+// Reading every vector back from the database happens once per profile,
+// and again only after a rolled-back write.
 export class RecallStore {
   constructor(db) {
     this.db = db;
     this.vectors = new Map();
   }
+  // Forget the memory copy; the next search reads it again.
+  invalidate() {
+    for (const cache of this.vectors.values()) cache.dirty = true;
+  }
+  #drop(id) {
+    for (const cache of this.vectors.values()) {
+      if (cache.dirty) continue;
+      const part = cache.kinds.get(kindOf(id));
+      const at = part?.index.get(id);
+      if (at === undefined) continue;
+      const last = part.ids.length - 1;
+      if (at !== last) {
+        part.ids[at] = part.ids[last];
+        part.rows[at] = part.rows[last];
+        part.index.set(part.ids[at], at);
+      }
+      part.ids.pop();
+      part.rows.pop();
+      part.index.delete(id);
+    }
+  }
   get(id) {
     return this.db.prepare("SELECT * FROM mind_index WHERE id=?").get(id);
   }
@@ -95,8 +122,12 @@ export class RecallStore {
         this.db
           .prepare("INSERT INTO mind_index_fts(item_id,tokens) VALUES (?,?)")
           .run(item.id, tokens);
-      this.db.prepare("DELETE FROM mind_vectors WHERE item_id=?").run(item.id);
-      for (const cache of this.vectors.values()) cache.dirty = true;
+      if (old) {
+        this.db
+          .prepare("DELETE FROM mind_vectors WHERE item_id=?")
+          .run(item.id);
+        this.#drop(item.id);
+      }
     }
     this.db
       .prepare("DELETE FROM mind_index_people WHERE item_id=?")
@@ -114,7 +145,7 @@ export class RecallStore {
     this.db.prepare("DELETE FROM mind_index_fts WHERE item_id=?").run(id);
     this.db.prepare("DELETE FROM mind_index_people WHERE item_id=?").run(id);
     this.db.prepare("DELETE FROM mind_vectors WHERE item_id=?").run(id);
-    if (existed) for (const cache of this.vectors.values()) cache.dirty = true;
+    this.#drop(id);
     return !!existed;
   }
   // Re-read one memory from where it lives. Gone or hidden means gone here.
@@ -150,6 +181,7 @@ export class RecallStore {
       this.db.exec("RELEASE recall_reconcile");
     } catch (error) {
       this.db.exec("ROLLBACK TO recall_reconcile");
+      this.invalidate();
       this.db.exec("RELEASE recall_reconcile");
       throw error;
     }
@@ -199,6 +231,7 @@ export class RecallStore {
       this.db.exec("RELEASE recall_catch_up");
     } catch (error) {
       this.db.exec("ROLLBACK TO recall_catch_up");
+      this.invalidate();
       this.db.exec("RELEASE recall_catch_up");
       throw error;
     }
@@ -232,6 +265,7 @@ export class RecallStore {
           this.db.exec("COMMIT");
         } catch (error) {
           this.db.exec("ROLLBACK");
+          this.invalidate();
           throw error;
         }
         await new Promise((resolve) => setImmediate(resolve));
@@ -271,6 +305,27 @@ export class RecallStore {
       )
       .get(profile);
   }
+  // Vectors are derived data kept per embedding profile. After a model
+  // change the old profile's rows would stay forever, doubling the table
+  // with every switch. The active profile and the most recent other one (a
+  // way back without paying to embed everything again) are kept; older
+  // profiles are dropped. Returns how many rows were removed.
+  pruneProfiles(active, { keepOthers = 1 } = {}) {
+    if (!active) return 0;
+    const others = this.db
+      .prepare(
+        "SELECT profile,MAX(created) last FROM mind_vectors WHERE profile!=? GROUP BY profile ORDER BY last DESC",
+      )
+      .all(active)
+      .slice(keepOthers);
+    let removed = 0;
+    for (const { profile } of others)
+      removed += Number(
+        this.db.prepare("DELETE FROM mind_vectors WHERE profile=?").run(profile)
+          .changes,
+      );
+    return removed;
+  }
   // A vector is stored only if the words it was made from are still current.
   saveVector(id, profile, hash, vector, now) {
     const current = this.db
@@ -283,53 +338,67 @@ export class RecallStore {
       )
       .run(id, profile, hash, vector.length, toBlob(vector), now);
     const cache = this.vectors.get(profile);
-    if (cache && !cache.dirty) {
-      const at = cache.index.get(id);
-      if (at === undefined) {
-        cache.index.set(id, cache.ids.length);
-        cache.ids.push(id);
-        cache.rows.push(vector);
-      } else cache.rows[at] = vector;
-    }
+    if (cache && !cache.dirty)
+      this.#place(cache, id, Float32Array.from(vector));
     return true;
   }
+  #place(cache, id, vector) {
+    const kind = kindOf(id);
+    let part = cache.kinds.get(kind);
+    if (!part) {
+      part = { ids: [], rows: [], index: new Map() };
+      cache.kinds.set(kind, part);
+    }
+    const at = part.index.get(id);
+    if (at === undefined) {
+      part.index.set(id, part.ids.length);
+      part.ids.push(id);
+      part.rows.push(vector);
+    } else part.rows[at] = vector;
+  }
   #cache(profile) {
     let cache = this.vectors.get(profile);
     if (!cache || cache.dirty) {
-      cache = { ids: [], rows: [], index: new Map(), dirty: false };
+      cache = { kinds: new Map(), dirty: false };
       for (const row of this.db
         .prepare(
           "SELECT v.item_id,v.vector FROM mind_vectors v JOIN mind_index i ON i.id=v.item_id AND i.text_hash=v.text_hash WHERE v.profile=?",
         )
-        .iterate(profile)) {
-        cache.index.set(row.item_id, cache.ids.length);
-        cache.ids.push(row.item_id);
-        cache.rows.push(fromBlob(row.vector));
-      }
+        .iterate(profile))
+        this.#place(cache, row.item_id, fromBlob(row.vector));
+      // Only the active profile is searched; a copy of an old one would sit
+      // in memory for nothing.
+      for (const key of this.vectors.keys())
+        if (key !== profile) this.vectors.delete(key);
       this.vectors.set(profile, cache);
     }
     return cache;
   }
   vector(id, profile) {
-    const cache = this.#cache(profile);
-    const at = cache.index.get(id);
-    return at === undefined ? null : cache.rows[at];
+    const part = this.#cache(profile).kinds.get(kindOf(id));
+    const at = part?.index.get(id);
+    return at === undefined ? null : part.rows[at];
   }
-  // Exact nearest items. `allow` filters before ranking, so what may not be
-  // recalled here never takes a place in the list.
+  // Exact nearest items. `kinds` limits the walk to those kinds; `allow`
+  // filters before ranking, so what may not be recalled here never takes a
+  // place in the list.
   nearest(
     profile,
     query,
-    { limit = 50, allow = () => true, minScore = 0 } = {},
+    { limit = 50, allow = () => true, minScore = 0, kinds = null } = {},
   ) {
     const cache = this.#cache(profile);
     const hits = [];
-    for (let i = 0; i < cache.ids.length; i++) {
-      const id = cache.ids[i];
-      if (!allow(id)) continue;
-      const score = dot(query, cache.rows[i]);
-      if (score >= minScore) hits.push({ id, score });
-    }
+    const parts = kinds
+      ? kinds.map((kind) => cache.kinds.get(kind)).filter(Boolean)
+      : [...cache.kinds.values()];
+    for (const part of parts)
+      for (let i = 0; i < part.ids.length; i++) {
+        const id = part.ids[i];
+        if (!allow(id)) continue;
+        const score = dot(query, part.rows[i]);
+        if (score >= minScore) hits.push({ id, score });
+      }
     hits.sort((a, b) => b.score - a.score);
     return hits.slice(0, limit);
   }
@@ -365,4 +434,18 @@ export class RecallStore {
       .all(id)
       .map((row) => row.user_id);
   }
+  // The people of many items in one read, for ranking a candidate list.
+  peopleOf(ids) {
+    const out = new Map(ids.map((id) => [id, []]));
+    for (let i = 0; i < ids.length; i += 400) {
+      const part = ids.slice(i, i + 400);
+      for (const row of this.db
+        .prepare(
+          `SELECT item_id,user_id FROM mind_index_people WHERE item_id IN (${part.map(() => "?").join(",")})`,
+        )
+        .all(...part))
+        out.get(row.item_id)?.push(row.user_id);
+    }
+    return out;
+  }
 }

package/server/mind/salience.js

@@ -97,7 +97,28 @@ export function grounded(content, texts) {
   const said = interestTerms(texts);
   const terms = [...interestTerms([content])];
   if (!terms.length || !said.size) return false;
-  return said.has(terms.at(-1));
+  if (said.has(terms.at(-1))) return true;
+  // A paraphrase that ends in its own words ("把篮球也推掉了") is still
+  // grounded when every clause it makes touches something that was said.
+  // A word repeated across clauses, usually the person's name, does not
+  // count for any of them. A single clause keeps the rule above: its last
+  // word is where the claim sits ("他下个月要结婚").
+  const clauses = String(content)
+    .split(/[，,。；;！!？?\n]+/)
+    .map((clause) => [...interestTerms([clause])])
+    .filter((clause) => clause.length);
+  const seen = new Map();
+  for (const clause of clauses)
+    for (const term of new Set(clause))
+      seen.set(term, (seen.get(term) || 0) + 1);
+  return (
+    clauses.length > 1 &&
+    clauses.every(
+      (clause) =>
+        new Set(clause.filter((term) => seen.get(term) === 1 && said.has(term)))
+          .size > 0,
+    )
+  );
 }
 
 // One set, or one set per speaker. An empty list means nothing was said.

package/server/mind/schema.js

@@ -1,3 +1,4 @@
+import { migrateAftermath } from "./aftermath.js";
 import { randomUUID } from "node:crypto";
 import { NATURE_DEFAULTS, NATURE_FIELDS } from "./nature.js";
 import { evidence, parse } from "./util.js";
@@ -88,6 +89,10 @@ export function migrateMind(db, store) {
   addColumn("mind_meetings", "reason", "TEXT NOT NULL DEFAULT ''");
   addColumn("mind_anticipations", "activity", "TEXT NOT NULL DEFAULT ''");
   addColumn("mind_self", "subject", "TEXT");
+  // What came to mind when she chose: index ids of the past put in front of
+  // her for that turn. Kept for good, unlike the turn's trace.
+  addColumn("mind_choices", "recalled", "TEXT NOT NULL DEFAULT '[]'");
+  migrateAftermath(addColumn);
   db.prepare(
     "UPDATE mind_runs SET status='interrupted',finished=? WHERE status='running'",
   ).run(Date.now());