luckytri 1.1.2 → 1.2.0

package/server/mind/aftermath.js

@@ -0,0 +1,169 @@
+// What happened after she chose: whether anyone answered her, how they
+// sounded, whether she may have been corrected, whether someone called her
+// again after she kept quiet, and how the owner tagged the reply. Read only
+// from the record (events, message cues, reply feedback), never from a
+// model, so it can be cleared and computed again. It is an experience to
+// look back on, not a score: nothing here is summed into a reward.
+
+const HOUR = 3600000;
+export const WINDOW_MS = 2 * HOUR;
+export const WINDOW_MESSAGES = 20;
+// Said to her, these usually mean she got something wrong. Only a hint:
+// "可能" is all it ever claims, with the message beside it.
+const CORRECTION =
+  /(?:^|[，,。！!？?\s])(?:你|您)?(?:不是(?:的|啦|吧)?|不对|没有啦|才不是|搞错|记错|说错|弄错|错了|并没有|不是这样)/;
+
+const parse = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+};
+
+export function migrateAftermath(addColumn) {
+  // What happened next, as JSON; '' until the window has closed.
+  addColumn("mind_choices", "after", "TEXT NOT NULL DEFAULT ''");
+}
+
+// The window closes at her next choice in the room, two hours after this
+// one, or twenty messages later, whichever comes first. The message that
+// moved her to choose again still belongs to this window.
+function windowEnd(db, choice) {
+  const next = db
+    .prepare(
+      "SELECT MIN(created) at FROM mind_choices WHERE session_id=? AND created>? ",
+    )
+    .get(choice.session_id, choice.created)?.at;
+  return Math.min(next ?? Infinity, choice.created + WINDOW_MS);
+}
+
+// Pure read: what came after one choice, or null while the window is open.
+export function aftermathOf(db, choice, now) {
+  const end = windowEnd(db, choice);
+  if (end === choice.created + WINDOW_MS && now < end) return null;
+  const spoke = choice.choice !== "silent";
+  const from = Number(choice.watermark) || 0;
+  const rows = db
+    .prepare(
+      "SELECT seq,role,time,payload FROM core_events WHERE session_id=? AND seq>? AND time>=? AND time<=? ORDER BY seq LIMIT ?",
+    )
+    .all(choice.session_id, from, choice.created, end, WINDOW_MESSAGES + 10);
+  // When she spoke, what others said before her words landed is not an
+  // answer to them.
+  const own = rows.findIndex((row) => row.role === "assistant");
+  const start = spoke && own >= 0 ? own + 1 : 0;
+  const after = rows
+    .slice(start)
+    .filter((row) => row.role !== "assistant")
+    .slice(0, WINDOW_MESSAGES)
+    .map((row) => ({ ...row, m: parse(row.payload) }));
+  const toHer = after.filter(
+    (row) => row.m.replyToBot === true || row.m.mentioned === true,
+  );
+  const cue = db.prepare("SELECT tone FROM core_message_cues WHERE seq=?");
+  const tone = [
+    ...new Set(
+      toHer
+        .map((row) => {
+          try {
+            return cue.get(row.seq)?.tone;
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean),
+    ),
+  ];
+  const corrected = spoke
+    ? toHer.filter((row) => CORRECTION.test(String(row.m.text || "")))
+    : [];
+  // The owner's tag sits on the logged reply, whose text is what she sent.
+  let feedback = [];
+  if (spoke && own >= 0) {
+    const sent = [];
+    for (let i = own; i < rows.length && rows[i].role === "assistant"; i++)
+      sent.push(String(parse(rows[i].payload).text || ""));
+    try {
+      feedback = db
+        .prepare(
+          "SELECT f.tag FROM decisions d JOIN reply_feedback f ON f.decision_id=d.id WHERE d.session_id=? AND d.reply=? AND COALESCE(d.is_demo,0)=0 ORDER BY d.id DESC LIMIT 1",
+        )
+        .all(choice.session_id, sent.join("\n"))
+        .map((row) => row.tag);
+    } catch {
+      feedback = [];
+    }
+  }
+  const first = toHer[0];
+  return {
+    v: 1,
+    spoke,
+    answered: spoke ? toHer.length > 0 : undefined,
+    calledAgain: spoke ? undefined : toHer.length > 0,
+    toHer: toHer.length,
+    others: after.length,
+    firstMin: first
+      ? Math.max(0, Math.round((first.time - choice.created) / 60000))
+      : null,
+    ...(tone.length ? { tone } : {}),
+    ...(corrected.length ? { corrected: "maybe" } : {}),
+    ...(feedback.length ? { feedback: [...new Set(feedback)] } : {}),
+    ...(spoke && own >= 0 ? { own: `m:${rows[own].seq}` } : {}),
+    refs: [...corrected, ...toHer.filter((row) => !corrected.includes(row))]
+      .slice(0, 4)
+      .map((row) => `m:${row.seq}`),
+  };
+}
+
+// Writes what came after for choices whose window has closed, oldest first,
+// a page at a time. Returns how many were written.
+export function settleAftermath(db, { now, limit = 50 } = {}) {
+  const rows = db
+    .prepare(
+      `SELECT c.id,c.created,c.session_id,c.choice,c.watermark FROM mind_choices c
+       WHERE c.after='' AND (c.created<=? OR EXISTS (SELECT 1 FROM mind_choices n WHERE n.session_id=c.session_id AND n.created>c.created))
+       ORDER BY c.created LIMIT ?`,
+    )
+    .all(now - WINDOW_MS, limit);
+  if (!rows.length) return 0;
+  const write = db.prepare(
+    "UPDATE mind_choices SET after=? WHERE id=? AND after=''",
+  );
+  let written = 0;
+  db.exec("SAVEPOINT aftermath");
+  try {
+    for (const row of rows) {
+      const after = aftermathOf(db, row, now);
+      if (after) written += write.run(JSON.stringify(after), row.id).changes;
+    }
+    db.exec("RELEASE aftermath");
+  } catch (error) {
+    db.exec("ROLLBACK TO aftermath");
+    db.exec("RELEASE aftermath");
+    throw error;
+  }
+  return written;
+}
+
+// How the record reads back in a line, for her and for the audit.
+export function describeAftermath(after) {
+  if (!after || typeof after !== "object") return "";
+  const parts = [];
+  if (after.spoke) {
+    parts.push(
+      after.answered
+        ? `有人接了我的话${after.firstMin != null ? `（${after.firstMin} 分钟后）` : ""}`
+        : after.others
+          ? "没人接我的话，大家接着聊别的"
+          : "说完以后没人再说话",
+    );
+    if (after.corrected) parts.push("可能说错了，被纠正");
+  } else {
+    parts.push(after.calledAgain ? "我没出声，之后又有人叫我" : "我没出声");
+  }
+  if (after.tone?.length) parts.push(`对方的语气：${after.tone.join("、")}`);
+  if (after.feedback?.length)
+    parts.push(`主人的反馈：${after.feedback.join("、")}`);
+  return parts.join("；");
+}

package/server/mind/anticipations.js

@@ -268,6 +268,8 @@ export class Anticipations {
         origin,
         kind === "plan" && isExecutable(activity) ? activity : "",
       );
+    // Searchable, and dated in the audit, from the moment it is made.
+    this.mind.recall?.sync("anticipation", id);
     return { id };
   }
   get(id) {

package/server/mind/clock.js

@@ -1,83 +1,91 @@
-import { localClock } from "../core/conversation-cues.js";
-
-export const JUST_NOW = 5 * 60000;
-
-export function elapsedLabel(time, now, zone = "Asia/Shanghai") {
-  const age = Math.max(0, now - time);
-  if (age < JUST_NOW) return "刚才";
-  const day = localClock(time, zone).local.slice(0, 10);
-  const today = localClock(now, zone).local.slice(0, 10);
-  if (day === today) return "今天早些时候";
-  if (day === localClock(now - 86400000, zone).local.slice(0, 10))
-    return "昨天";
-  return age < 7 * 86400000 ? "好几天前" : "很久以前";
-}
-
-// Coarse distance in time, the way a person would say it.
-export function agoLabel(ms) {
-  const days = Math.floor(Math.max(0, ms) / 86400000);
-  if (days < 1) return "今天";
-  if (days < 2) return "昨天";
-  if (days < 7) return `${days} 天前`;
-  if (days < 30) return `${Math.floor(days / 7)} 周前`;
-  if (days < 365) return `${Math.floor(days / 30)} 个月前`;
-  return `${Math.floor(days / 365)} 年前`;
-}
-
-export function topicWeight(
-  time,
-  now,
-  { importance = 0, mentions = 1, open = false } = {},
-) {
-  const halfLife = (open ? 48 : 6) * 3600000 * (1 + Math.min(1, importance));
-  return Math.min(
-    1,
-    Math.pow(0.5, Math.max(0, now - time) / halfLife) *
-      (1 + Math.min(3, mentions - 1) * 0.1),
-  );
-}
-
-export function timePhase(lastTime, now) {
-  if (!lastTime)
-    return {
-      key: "unfamiliar",
-      label: "还未相遇",
-      description: "还没有真实聊天，时间暂时没有可以延续的落点。",
-    };
-  const age = Math.max(0, now - lastTime);
-  if (age < 30 * 60000)
-    return {
-      key: "present",
-      label: "仍在对话里",
-      description: "刚才的语气和话题仍然清晰，适合自然接着聊。",
-    };
-  if (age < 3 * 3600000)
-    return {
-      key: "afterglow",
-      label: "留有余韵",
-      description: "聊天刚安静下来，刚才没说完的事还会留在注意里。",
-    };
-  if (age < 12 * 3600000)
-    return {
-      key: "settled",
-      label: "各自生活",
-      description: "注意力已经离开即时对话，但重要的事仍可能被想起。",
-    };
-  if (age < 2 * 86400000)
-    return {
-      key: "quiet",
-      label: "安静了一阵",
-      description: "旧话题正在降温，未完成的事情比普通闲聊更容易被想起。",
-    };
-  if (age < 7 * 86400000)
-    return {
-      key: "remembering",
-      label: "偶尔想起",
-      description: "相隔已有几天，熟悉感还在，但重新开口需要具体缘由。",
-    };
-  return {
-    key: "reunion",
-    label: "等待重逢",
-    description: "已经隔了很久，旧事只保留为背景，新的消息会成为新的相遇。",
-  };
-}
+import { localClock } from "../core/conversation-cues.js";
+
+export const JUST_NOW = 5 * 60000;
+
+export function elapsedLabel(time, now, zone = "Asia/Shanghai") {
+  const age = Math.max(0, now - time);
+  if (age < JUST_NOW) return "刚才";
+  const day = localClock(time, zone).local.slice(0, 10);
+  const today = localClock(now, zone).local.slice(0, 10);
+  if (day === today) return "今天早些时候";
+  if (day === localClock(now - 86400000, zone).local.slice(0, 10))
+    return "昨天";
+  const days = age / 86400000;
+  if (days < 7) return "好几天前";
+  // Nine days and two years ago should not read the same.
+  if (days < 14) return "一周前";
+  if (days < 30) return "两三周前";
+  if (days < 60) return "一个多月前";
+  if (days < 365) return "几个月前";
+  if (days < 730) return "一年多前";
+  return "很久以前";
+}
+
+// Coarse distance in time, the way a person would say it.
+export function agoLabel(ms) {
+  const days = Math.floor(Math.max(0, ms) / 86400000);
+  if (days < 1) return "今天";
+  if (days < 2) return "昨天";
+  if (days < 7) return `${days} 天前`;
+  if (days < 30) return `${Math.floor(days / 7)} 周前`;
+  if (days < 365) return `${Math.floor(days / 30)} 个月前`;
+  return `${Math.floor(days / 365)} 年前`;
+}
+
+export function topicWeight(
+  time,
+  now,
+  { importance = 0, mentions = 1, open = false } = {},
+) {
+  const halfLife = (open ? 48 : 6) * 3600000 * (1 + Math.min(1, importance));
+  return Math.min(
+    1,
+    Math.pow(0.5, Math.max(0, now - time) / halfLife) *
+      (1 + Math.min(3, mentions - 1) * 0.1),
+  );
+}
+
+export function timePhase(lastTime, now) {
+  if (!lastTime)
+    return {
+      key: "unfamiliar",
+      label: "还未相遇",
+      description: "还没有真实聊天，时间暂时没有可以延续的落点。",
+    };
+  const age = Math.max(0, now - lastTime);
+  if (age < 30 * 60000)
+    return {
+      key: "present",
+      label: "仍在对话里",
+      description: "刚才的语气和话题仍然清晰，适合自然接着聊。",
+    };
+  if (age < 3 * 3600000)
+    return {
+      key: "afterglow",
+      label: "留有余韵",
+      description: "聊天刚安静下来，刚才没说完的事还会留在注意里。",
+    };
+  if (age < 12 * 3600000)
+    return {
+      key: "settled",
+      label: "各自生活",
+      description: "注意力已经离开即时对话，但重要的事仍可能被想起。",
+    };
+  if (age < 2 * 86400000)
+    return {
+      key: "quiet",
+      label: "安静了一阵",
+      description: "旧话题正在降温，未完成的事情比普通闲聊更容易被想起。",
+    };
+  if (age < 7 * 86400000)
+    return {
+      key: "remembering",
+      label: "偶尔想起",
+      description: "相隔已有几天，熟悉感还在，但重新开口需要具体缘由。",
+    };
+  return {
+    key: "reunion",
+    label: "等待重逢",
+    description: "已经隔了很久，旧事只保留为背景，新的消息会成为新的相遇。",
+  };
+}

package/server/mind/discretion.js

@@ -0,0 +1,20 @@
+// How a privately learned thing reaches her in a public place: she keeps the
+// content and its source to herself. Keeping is not denying: pretending she
+// never heard it would be a lie of its own.
+export const PRIVATELY_KNOWN =
+  "私下知道的：当众不说内容，也不说从哪听来；有人追问就说这不该在这儿讲，不装作不知道";
+
+// What she sees of a private thing in a place where she may not repeat it.
+// The content stays out, but she is not left blind: the words that people
+// here have already said aloud and that the thing is about are named, so she
+// knows she does know, and can keep it rather than claim she never heard.
+export function withheldMemory(content, said = []) {
+  const heard = new Set(said);
+  const shared = [...heard].filter(
+    (term) => term.length >= 2 && String(content).includes(term),
+  );
+  const topic = shared.slice(0, 3).join("、");
+  return topic
+    ? `（关于此人的一件私下的事，和这里刚说到的「${topic}」有关；内容不在这里复述）`
+    : "（关于此人的一条受限记忆；没有在这里复述具体内容的授权）";
+}

package/server/mind/episodes.js

@@ -1,3 +1,4 @@
+import { PRIVATELY_KNOWN } from "./discretion.js";
 import { randomUUID } from "node:crypto";
 import { applySpeakerNames } from "../core/speaker-names.js";
 import { elapsedLabel } from "./clock.js";
@@ -235,7 +236,7 @@ export class Episodes {
       updated: elapsedLabel(last.created, now, zone),
       ...(last.basis === "stated" ? { basis: "对方告诉你的" } : {}),
       ...(!local && isPrivateSession(last.session_id)
-        ? { discretion: "私下知道的，不要当众说出口，也不要说出从哪听来" }
+        ? { discretion: PRIVATELY_KNOWN }
         : {}),
     };
   }

package/server/mind/index.js

@@ -87,6 +87,17 @@ const TURN_CHANGES = new Set(
   ),
 );
 
+// One entry per item of her past that was in front of her, first reason
+// kept. Ids are recall index ids ("fact:…", "episode:…", "self:…").
+function recalledLedger(items) {
+  const seen = new Map();
+  for (const item of Array.isArray(items) ? items : []) {
+    const id = String(item?.id || "");
+    if (id && !seen.has(id)) seen.set(id, String(item.why || "").slice(0, 24));
+  }
+  return [...seen].slice(0, 60).map(([id, why]) => ({ id, why }));
+}
+
 // One of her, across every conversation. Sessions only say where something
 // happened; they are no longer walls between parts of her.
 export class Mind {
@@ -94,6 +105,8 @@ export class Mind {
     this.repo = repo;
     this.db = repo.db;
     this.store = repo.store;
+    // Her clock, so a tombstone sits on the same timeline as what it buries.
+    this.now = now;
     migrateMind(this.db, this.store);
     this.backoff = new Backoff(this.db);
     this.embedding = new EmbeddingService(repo, models, { now });
@@ -186,11 +199,12 @@ export class Mind {
     reason = "",
     watermark = null,
     occasion = null,
+    recalled = [],
     time = Date.now(),
   }) {
     this.db
       .prepare(
-        "INSERT INTO mind_choices(id,created,session_id,trace_id,choice,appraisal,reason,watermark,occasion) VALUES (?,?,?,?,?,?,?,?,?)",
+        "INSERT INTO mind_choices(id,created,session_id,trace_id,choice,appraisal,reason,watermark,occasion,recalled) VALUES (?,?,?,?,?,?,?,?,?,?)",
       )
       .run(
         randomUUID(),
@@ -202,6 +216,7 @@ export class Mind {
         text(reason, 300),
         watermark,
         occasion,
+        JSON.stringify(recalledLedger(recalled)),
       );
   }
   choices({ session = "", limit = 30, before = Number.MAX_SAFE_INTEGER } = {}) {
@@ -337,7 +352,7 @@ export class Mind {
         .prepare(
           "INSERT INTO mind_revocations(id,created,target_kind,target_id,content,reason) VALUES (?,?,?,?,?,?)",
         )
-        .run(randomUUID(), Date.now(), kind, id, content, note);
+        .run(randomUUID(), this.now(), kind, id, content, note);
     if (kind === "memory") return this.memory.revoke(id, note);
     if (kind === "self") {
       const rows = this.self.history(id);

package/server/mind/initiative.js

@@ -83,9 +83,9 @@ export class Initiative {
           if (!row.subject) return true;
           const seen = this.db
             .prepare(
-              "SELECT 1 FROM core_events WHERE session_id=? AND role='user' AND payload LIKE ? LIMIT 1",
+              "SELECT 1 FROM core_events WHERE session_id=? AND role='user' AND json_extract(payload,'$.userId')=? LIMIT 1",
             )
-            .get(session, `%"userId":"${row.subject}"%`);
+            .get(session, String(row.subject));
           return !!seen;
         })
         .slice(0, 3)
@@ -322,6 +322,15 @@ export class Initiative {
     }
     return material;
   }
+  recentUserWords(session, limit = 50) {
+    return this.db
+      .prepare(
+        "SELECT payload FROM core_events WHERE session_id=? AND role='user' AND seq NOT IN (SELECT seq FROM mind_unlived) AND COALESCE(json_extract(payload,'$.simulated'),0)=0 ORDER BY seq DESC LIMIT ?",
+      )
+      .all(session, limit)
+      .map((row) => parse(row.payload, {}).text || "")
+      .reverse();
+  }
   blocked(session, now, settings) {
     if (!session || !this.life.chat.enabled(session, { simulated: false }))
       return { reason: "会话不可用", permanent: true };
@@ -332,18 +341,10 @@ export class Initiative {
         reason: "对方没有开启主动消息，等对方来找她",
         retryAt: now + 6 * HOUR,
       };
-    const lastUser = this.db
-      .prepare(
-        "SELECT time,payload FROM core_events WHERE session_id=? AND role='user' AND seq NOT IN (SELECT seq FROM mind_unlived) AND COALESCE(json_extract(payload,'$.simulated'),0)=0 ORDER BY seq DESC LIMIT 1",
-      )
-      .get(session);
-    const words = parse(lastUser?.payload, {}).text || "";
-    // Explicit contact boundaries are different from “this message needs no reply”.
-    if (
-      /(?:别|不要|不用)再?(?:主动)?(?:给我发消息|找我|联系我|私聊我)|别再打扰我/.test(
-        words,
-      )
-    )
+    // Explicit contact boundaries are different from “this message needs no
+    // reply”. A boundary stays after the person goes on talking about other
+    // things; only their own later invitation lifts it.
+    if (contactBoundary(this.recentUserWords(session)))
       return { reason: "对方明确不想被主动联系", permanent: true };
     if (this.life.chat.queue.lanes.has(session))
       return { reason: "这段对话正在处理，稍后重新看看", retryAt: now + 60000 };
@@ -354,3 +355,17 @@ export class Initiative {
     return null;
   }
 }
+
+const BOUNDARY =
+  /(?:别|不要|不用)再?(?:主动)?(?:给我发消息|找我|联系我|私聊我)|别再打扰我/;
+const INVITATION =
+  /(?:可以|随时|有空|想聊)(?:就)?(?:主动)?(?:找我|联系我|私聊我|给我发消息)|(?:你|您)(?:可以|能)?主动(?:找|联系)我/;
+// Whether the latest word on being contacted, oldest first, is a boundary.
+export function contactBoundary(words) {
+  let held = false;
+  for (const said of words || []) {
+    if (INVITATION.test(said)) held = false;
+    else if (BOUNDARY.test(said)) held = true;
+  }
+  return held;
+}

package/server/mind/memory.js

@@ -1,3 +1,4 @@
+import { PRIVATELY_KNOWN, withheldMemory } from "./discretion.js";
 import { randomUUID } from "node:crypto";
 import {
   parseSessionKey,
@@ -52,7 +53,11 @@ function recallQuery(rows) {
   const seen = new Set();
   for (const row of [...rows].reverse()) {
     if (row.role === "assistant") continue;
-    for (const term of lexicalTerms(row.text || ""))
+    // The line a short follow-up leans on comes after its own words, so a
+    // long context never crowds the follow-up out of the term budget.
+    for (const term of lexicalTerms(
+      [row.text, row.context].filter(Boolean).join(" "),
+    ))
       if (!seen.has(term)) {
         seen.add(term);
         terms.push(term);
@@ -133,7 +138,10 @@ export class MemoryManager {
       const id = String(row.userId || "");
       if (!id) continue;
       const terms = saidBy.get(id) || new Set();
-      for (const term of lexicalTerms(row.text || "")) terms.add(term);
+      for (const term of lexicalTerms(
+        [row.context, row.text].filter(Boolean).join(" "),
+      ))
+        terms.add(term);
       saidBy.set(id, terms);
     }
     const oneSpeakerOverlap = (content) => {
@@ -254,7 +262,9 @@ export class MemoryManager {
         subject: m.subject,
         content:
           forSpeech && !this.permission(m, session, cutoff).disclose
-            ? "（关于此人的一条受限记忆；没有在这里复述具体内容的授权）"
+            ? withheldMemory(m.content, [
+                ...new Set([...saidBy.values()].flatMap((t) => [...t])),
+              ])
             : m.content,
         type: m.type,
         confidence: m.confidence,
@@ -268,11 +278,43 @@ export class MemoryManager {
         // Old news may no longer be true; she should know how old it is.
         ...(age >= 7 * DAY ? { when: `${agoLabel(age)}知道的` } : {}),
         ...(m.discretion === "private" && !local
-          ? { discretion: "私下知道的，不要当众说出口，也不要说出从哪听来" }
+          ? { discretion: PRIVATELY_KNOWN }
           : {}),
+        ...this.conflictNote(m, session, cutoff, forSpeech),
       };
     });
   }
+  // Two statements marked as not fitting together, both still held: when one
+  // comes back, she sees the other beside it, with when and where she heard
+  // it, instead of taking either for settled.
+  conflictNote(m, session, now = Date.now(), forSpeech = false) {
+    const ref = `fact:${m.id}`;
+    const other = this.repo.db
+      .prepare(
+        `SELECT m.* FROM mind_links l JOIN core_memories m
+           ON 'fact:' || m.id = CASE WHEN l.from_id=? THEN l.to_id ELSE l.from_id END
+         WHERE l.relation='conflicts' AND (l.from_id=? OR l.to_id=?)
+           AND m.status='confirmed' AND (m.expires IS NULL OR m.expires>?)
+         ORDER BY m.created DESC LIMIT 1`,
+      )
+      .get(ref, ref, ref, now);
+    if (!other) return {};
+    const allowed = this.permission(other, session, now);
+    if (!allowed.recall) return {};
+    if (forSpeech && !allowed.disclose)
+      return { conflictsWith: "另有一条对不上的说法（受限，不在这里复述）" };
+    const age = now - Number(other.created || now);
+    const where =
+      this.scopes(session).includes(other.session_id) ||
+      other.session_id === "__shared__"
+        ? "这里"
+        : isPrivateSession(other.session_id)
+          ? "私聊里"
+          : "别的群里";
+    return {
+      conflictsWith: `另一个对不上的说法：「${String(other.content).slice(0, 60)}」（${age >= DAY ? `${agoLabel(age)}，` : ""}${where}听到的；哪个现在成立还不确定）`,
+    };
+  }
   secretsOutside(session) {
     return this.#outside(session, "secret");
   }
@@ -414,7 +456,7 @@ export class MemoryManager {
       )
       .run(
         randomUUID(),
-        Date.now(),
+        this.mind?.now?.() ?? Date.now(),
         "memory",
         id,
         `${row.subject}\n${row.content}`,