luckytri 1.0.0 → 1.0.2

package/server/mind/anticipations.js

@@ -1,507 +1,507 @@
-import { randomUUID } from "node:crypto";
-import { localClock } from "../core/conversation-cues.js";
-import { hasCredential } from "./guard.js";
-import { isPrivateSession } from "./memory.js";
-import { lifeSpan } from "./nature.js";
-import { classifyActivity, isExecutable } from "./time/tasks.js";
-import { taskIntent } from "./time/intent.js";
-import { DAY, evidence, parse, similar, text, zonedTime } from "./util.js";
-
-// What she is looking ahead to: promises she made, things she means to do,
-// what others told her is coming, and the dates that come back every year.
-export const ANTICIPATION_KINDS = {
-  promise: "答应的事",
-  plan: "想做的事",
-  event: "别人的安排",
-  date: "每年的日子",
-};
-// How long after its day something still waits to be asked about or done
-// before it quietly counts as missed.
-const GRACE = { event: 3 * DAY, promise: 7 * DAY, plan: 7 * DAY, date: 0 };
-const HORIZON = 400 * DAY;
-const CLOSE = new Set(["done", "missed", "let_go"]);
-
-function row(value) {
-  return value
-    ? {
-        ...value,
-        sources: parse(value.sources, []),
-        closed_sources: parse(value.closed_sources, []),
-      }
-    : null;
-}
-
-export class Anticipations {
-  constructor(mind) {
-    this.mind = mind;
-    this.db = mind.db;
-  }
-  day(time) {
-    return localClock(time, this.mind.timeZone()).local.slice(0, 10);
-  }
-  // A yearly date's next return (or today's), otherwise the one due moment.
-  occurrence(a, now) {
-    if (a.recurrence !== "yearly") return a.due_at;
-    const monthDay = this.day(a.due_at).slice(5);
-    const year = Number(this.day(now).slice(0, 4));
-    for (const y of [year - 1, year, year + 1]) {
-      const at = zonedTime(`${y}-${monthDay}`, this.mind.timeZone());
-      if (at !== null && at + DAY > now) return at;
-    }
-    return a.due_at;
-  }
-  ends(a, due) {
-    return due + (a.due_precision === "time" ? 0 : DAY);
-  }
-  // From the start of the day before.
-  opens(due) {
-    const midnight = zonedTime(this.day(due), this.mind.timeZone());
-    return (midnight ?? due) - DAY;
-  }
-  // Her name for someone, or the name they last used where it was said.
-  who(a) {
-    if (!a.subject) return "";
-    const known = this.mind.bonds.name(a.subject);
-    if (known) return known;
-    const said = parse(
-      this.db
-        .prepare(
-          "SELECT payload FROM core_events WHERE session_id=? AND role='user' AND json_extract(payload,'$.userId')=? ORDER BY seq DESC LIMIT 1",
-        )
-        .get(a.session_id, String(a.subject))?.payload,
-      {},
-    );
-    return said.name || a.subject;
-  }
-  lapsed(a, now) {
-    return (
-      a.recurrence !== "yearly" &&
-      now > this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event)
-    );
-  }
-  // A private promise can be written in her diary. It cannot be carried out
-  // of that room, or into the story she retells everywhere.
-  concealed(a) {
-    return a.discretion !== "open" || isPrivateSession(a.session_id);
-  }
-  // Private rooms whose plans, promises, or dates the diary of `day` would see.
-  privateRooms(day, before = Date.now()) {
-    const nature = this.mind.nature.current(before);
-    const zone = this.mind.timeZone();
-    const span = lifeSpan(nature, day, zone);
-    if (!span || span.start > before) return [];
-    const end = Math.min(before, span.end);
-    const rooms = new Set();
-    for (const a of this.db
-      .prepare(
-        "SELECT * FROM mind_anticipations WHERE created<=? AND status!='revoked'",
-      )
-      .all(before)
-      .map(row)) {
-      if (!this.concealed(a) || !this.#onDay(a, span, end)) continue;
-      // The room where it was said may still see that day's diary. A marker
-      // with no room would hide the diary everywhere, including there.
-      rooms.add(a.session_id || `a:${a.id}`);
-    }
-    return [...rooms];
-  }
-  #onDay(a, span, before) {
-    const pending =
-      a.status === "pending" || (a.closed_at != null && a.closed_at > before);
-    if (
-      !pending &&
-      a.closed_at >= span.start &&
-      a.closed_at < span.end &&
-      a.closed_at <= before
-    )
-      return true;
-    if (a.recurrence === "yearly")
-      return this.day(this.occurrence(a, span.start)) === this.day(span.start);
-    if (a.due_at >= span.start && a.due_at < span.end) return true;
-    const lapse = this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event);
-    return pending && lapse >= span.start && lapse < span.end;
-  }
-  revokedContents() {
-    return this.db
-      .prepare(
-        "SELECT content FROM mind_revocations WHERE target_kind='anticipation'",
-      )
-      .all()
-      .map((r) => r.content)
-      .filter(Boolean);
-  }
-  add({
-    kind,
-    subject = null,
-    session = null,
-    content,
-    due,
-    recurrence = "none",
-    discretion = "open",
-    sources = [],
-    origin = "memory",
-    activity = "",
-    time = Date.now(),
-  }) {
-    if (!ANTICIPATION_KINDS[kind]) return { rejected: "类型无效" };
-    const words = text(content, 120);
-    if (!words || hasCredential(words)) return { rejected: "内容无效" };
-    const refs = evidence(sources);
-    if (!refs.length) return { rejected: "缺少来源" };
-    const when = String(due ?? "").trim();
-    const at = zonedTime(when, this.mind.timeZone());
-    if (at === null) return { rejected: "日期无效" };
-    const yearly = kind === "date" || recurrence === "yearly";
-    const precision = /\d{2}:\d{2}$/.test(when) ? "time" : "day";
-    if (
-      !yearly &&
-      (this.ends({ due_precision: precision }, at) <= time - DAY ||
-        at > time + HORIZON)
-    )
-      return { rejected: "日期不在合理范围" };
-    const who = subject ? String(subject) : "";
-    if (
-      this.revokedContents().some((old) =>
-        similar(old, `${who}\n${words}`, 0.75),
-      )
-    )
-      return { rejected: "与撤销过的内容相同" };
-    if (!yearly && ["plan", "promise"].includes(kind)) {
-      const input = {
-          title: words,
-          activity: activity || classifyActivity(words),
-          subject,
-          session,
-          sources: refs,
-        },
-        intent = taskIntent(this.db, input);
-      if (intent.key) {
-        const tracked = this.mind.time?.tasks.links.find(input);
-        const prior = tracked
-          ? this.mind.time.tasks.links
-              .anticipations(tracked)
-              .map((id) => this.get(id))
-              .find((a) => a && a.status !== "revoked")
-          : this.db
-              .prepare(
-                "SELECT * FROM mind_anticipations WHERE kind IN ('plan','promise') AND status='pending' ORDER BY created",
-              )
-              .all()
-              .find(
-                (a) =>
-                  taskIntent(this.db, {
-                    title: a.content,
-                    activity: a.activity || classifyActivity(a.content),
-                    subject: a.subject,
-                    session: a.session_id,
-                    sources: parse(a.sources, []),
-                  }).key === intent.key,
-              );
-        if (tracked || prior) {
-          if (tracked) {
-            this.mind.time.tasks.links.mergeSource(
-              tracked,
-              {
-                sources: refs,
-                kind,
-                subject: who || intent.recipient,
-                dueAt: at,
-                duePrecision: precision,
-                origin,
-              },
-              time,
-            );
-            if (tracked.state === "abandoned")
-              this.mind.time.tasks.links.close(
-                tracked,
-                "原事项已放下，重复整理不能恢复",
-                time,
-              );
-          } else
-            this.db
-              .prepare("UPDATE mind_anticipations SET sources=? WHERE id=?")
-              .run(
-                JSON.stringify(
-                  evidence([...parse(prior.sources, []), ...refs]),
-                ),
-                prior.id,
-              );
-          return {
-            duplicate: prior?.id || tracked.id,
-            task: tracked?.id,
-            suppressed: tracked?.state === "abandoned",
-          };
-        }
-      }
-    }
-    const key = yearly ? this.day(at).slice(5) : this.day(at);
-    const same = this.db
-      .prepare(
-        "SELECT * FROM mind_anticipations WHERE status='pending' AND COALESCE(subject,'')=? AND kind=?",
-      )
-      .all(who, kind)
-      .find(
-        (r) =>
-          (yearly ? this.day(r.due_at).slice(5) : this.day(r.due_at)) === key &&
-          similar(r.content, words, 0.6),
-      );
-    if (same) return { duplicate: same.id };
-    const id = randomUUID();
-    this.db
-      .prepare(
-        "INSERT INTO mind_anticipations(id,created,kind,subject,session_id,content,due_at,due_precision,recurrence,discretion,sources,origin,activity) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
-      )
-      .run(
-        id,
-        time,
-        kind,
-        who || null,
-        session,
-        words,
-        at,
-        precision,
-        yearly ? "yearly" : "none",
-        ["open", "private", "secret"].includes(discretion)
-          ? discretion
-          : "open",
-        JSON.stringify(refs),
-        origin,
-        kind === "plan" && isExecutable(activity) ? activity : "",
-      );
-    return { id };
-  }
-  get(id) {
-    return row(
-      this.db.prepare("SELECT * FROM mind_anticipations WHERE id=?").get(id),
-    );
-  }
-  // Still open at `now`; something closed later still counts when looking back.
-  pending(now = Date.now()) {
-    return this.db
-      .prepare(
-        "SELECT * FROM mind_anticipations WHERE created<=? AND (status='pending' OR (closed_at IS NOT NULL AND closed_at>? AND status!='revoked')) ORDER BY due_at",
-      )
-      .all(now, now)
-      .map(row);
-  }
-  close(id, { status, note = "", sources = [], time = Date.now() } = {}) {
-    if (!CLOSE.has(status)) return false;
-    const a = this.get(id);
-    if (!a || a.status !== "pending" || a.recurrence === "yearly") return false;
-    if (status === "done") {
-      if (
-        ["plan", "promise"].includes(a.kind) &&
-        (a.activity || classifyActivity(a.content) !== "unknown")
-      )
-        this.mind.time?.tasks.sync(time);
-      const task = this.db
-        .prepare(
-          "SELECT state,share_state FROM mind_time_tasks WHERE anticipation_id=?",
-        )
-        .get(id);
-      if (
-        task &&
-        (task.state !== "done" || !["none", "sent"].includes(task.share_state))
-      )
-        return false;
-    }
-    return (
-      this.db
-        .prepare(
-          "UPDATE mind_anticipations SET status=?,closed_at=?,closed_note=?,closed_sources=? WHERE id=? AND status='pending'",
-        )
-        .run(
-          status,
-          time,
-          text(note, 120),
-          JSON.stringify(evidence(sources)),
-          id,
-        ).changes > 0
-    );
-  }
-  revoke(id, reason = "") {
-    const a = this.get(id);
-    if (!a) throw Error("约定不存在");
-    this.db
-      .prepare(
-        "UPDATE mind_anticipations SET status='revoked',closed_at=?,closed_note=? WHERE id=?",
-      )
-      .run(Date.now(), text(reason, 120), id);
-    return `${a.subject || ""}\n${a.content}`;
-  }
-  relative(due, now, precision = "day") {
-    const zone = this.mind.timeZone();
-    const at = (t) =>
-      Date.parse(`${localClock(t, zone).local.slice(0, 10)}T00:00:00Z`);
-    const days = Math.round((at(due) - at(now)) / DAY);
-    const clock =
-      precision === "time" ? ` ${localClock(due, zone).local.slice(11)}` : "";
-    const named = {
-      0: "今天",
-      1: "明天",
-      2: "后天",
-      [-1]: "昨天",
-      [-2]: "前天",
-    };
-    if (named[days] !== undefined) return named[days] + clock;
-    return days > 0 ? `${days} 天后` : `${-days} 天前`;
-  }
-  label(a, due, now) {
-    const who = this.who(a);
-    const when = this.relative(due, now, a.due_precision);
-    if (a.kind === "promise") {
-      const task = this.db
-        .prepare(
-          "SELECT state,share_state,checkpoint FROM mind_time_tasks WHERE anticipation_id=?",
-        )
-        .get(a.id);
-      const progress =
-        task?.state === "done" && task.share_state !== "sent"
-          ? "作品完成，尚未交付"
-          : task?.state === "doing"
-            ? "正在做"
-            : parse(task?.checkpoint, {}).workId
-              ? "已有草稿，尚未完成"
-              : "还没做";
-      return `我答应${who ? `${who}` : ""}：${a.content}（${when}${a.status === "pending" ? "，" + progress : ""}）`;
-    }
-    if (a.kind === "plan") return `我打算：${a.content}（${when}）`;
-    if (a.kind === "event")
-      return `${who ? `${who}计划：` : "有人计划："}${a.content}（${when}，结果未确认）`;
-    return `${who ? `${who}：` : ""}${a.content}（${when}）`;
-  }
-  // Near enough to matter in a conversation: from the day before until a few
-  // days after, and only where it belongs.
-  upcoming({ now = Date.now(), people = [], session = "", limit = 3 } = {}) {
-    const here = new Set(session ? this.mind.memory.scopes(session) : []);
-    const present = new Set(people.map(String));
-    const out = [];
-    for (const a of this.pending(now)) {
-      const due = this.occurrence(a, now);
-      const after =
-        a.recurrence === "yearly" ? 0 : (GRACE[a.kind] ?? GRACE.event);
-      if (now < this.opens(due) || now >= this.ends(a, due) + after) continue;
-      // A plan by someone else in this room belongs to that person. Its
-      // presence in the same group must not make it A's plan when B said it.
-      const relevant = a.subject
-        ? present.has(String(a.subject))
-        : a.session_id === session || a.kind === "plan";
-      if (!relevant) continue;
-      const local = here.has(a.session_id);
-      if (a.discretion !== "open" && !local) continue;
-      out.push({ id: a.id, due, text: this.label(a, due, now) });
-      if (out.length >= limit) break;
-    }
-    return out;
-  }
-  // What she might think about when alone: due soon, just past, or quietly
-  // missed within the last week.
-  // What is still ahead comes first, soonest first. Then what was due but still
-  // waits (inside its grace), then what already lapsed; both the most recent
-  // first, so a week-old plan of someone else does not take the places from
-  // what is near now.
-  due({ now = Date.now(), limit = 5, shareable = false } = {}) {
-    const found = [];
-    for (const a of this.pending(now)) {
-      if (shareable && this.concealed(a)) continue;
-      const due = this.occurrence(a, now);
-      const after =
-        a.recurrence === "yearly"
-          ? 0
-          : (GRACE[a.kind] ?? GRACE.event) + 7 * DAY;
-      if (now < this.opens(due) || now >= this.ends(a, due) + after) continue;
-      const lapsed = this.lapsed(a, now);
-      // 0: its day has not passed yet; 1: due, still inside the grace;
-      // 2: already lapsed.
-      const rank = lapsed ? 2 : this.ends(a, due) <= now ? 1 : 0;
-      found.push({
-        due,
-        rank,
-        item: {
-          ref: `a:${a.id}`,
-          kind: ANTICIPATION_KINDS[a.kind],
-          ...(a.subject ? { who: this.who(a), userId: a.subject } : {}),
-          content: a.content,
-          when: this.relative(due, now, a.due_precision),
-          ...(lapsed ? { lapsed: true } : {}),
-          ...(a.recurrence === "yearly" ? { yearly: true } : {}),
-        },
-      });
-    }
-    return found
-      .sort(
-        (a, b) => a.rank - b.rank || (a.rank ? b.due - a.due : a.due - b.due),
-      )
-      .slice(0, limit)
-      .map((entry) => entry.item);
-  }
-  // Something she was looking ahead to has come close, or just passed.
-  newlyDue(since, now = Date.now()) {
-    return this.pending(now).some((a) => {
-      const due = this.occurrence(a, now);
-      const edges = [this.opens(due), this.ends(a, due)];
-      return edges.some((edge) => edge > since && edge <= now);
-    });
-  }
-  // The day's promises kept and missed, and the dates that fall on it.
-  today({ start, end, shareable = false }) {
-    const keep = (a) => !shareable || !this.concealed(a);
-    const closed = this.db
-      .prepare(
-        "SELECT * FROM mind_anticipations WHERE closed_at>=? AND closed_at<? AND status IN ('done','missed','let_go') ORDER BY closed_at",
-      )
-      .all(start, end)
-      .map(row)
-      .filter(keep);
-    const lapsedToday = this.pending(end).filter((a) => {
-      if (!keep(a) || a.recurrence === "yearly") return false;
-      const at = this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event);
-      return at >= start && at < end;
-    });
-    const line = (a) => this.label(a, this.occurrence(a, start), start);
-    const byStatus = (status) =>
-      closed.filter((a) => a.status === status).map(line);
-    return {
-      kept: byStatus("done"),
-      missed: [...byStatus("missed"), ...lapsedToday.map(line)],
-      letGo: byStatus("let_go"),
-      dates: this.pending(end)
-        .filter(
-          (a) =>
-            keep(a) &&
-            a.recurrence === "yearly" &&
-            this.day(this.occurrence(a, start)) === this.day(start),
-        )
-        .map(line),
-      dueToday: this.pending(end)
-        .filter(
-          (a) =>
-            keep(a) &&
-            a.recurrence !== "yearly" &&
-            a.due_at >= start &&
-            a.due_at < end,
-        )
-        .map(line),
-    };
-  }
-  list({ now = Date.now(), limit = 100 } = {}) {
-    return this.db
-      .prepare(
-        "SELECT * FROM mind_anticipations ORDER BY CASE status WHEN 'pending' THEN 0 ELSE 1 END, due_at LIMIT ?",
-      )
-      .all(limit)
-      .map(row)
-      .map((a) => {
-        const due = this.occurrence(a, now);
-        return {
-          ...a,
-          name: this.who(a),
-          occurrence: due,
-          when: this.relative(due, now, a.due_precision),
-          state:
-            a.status === "pending" && this.lapsed(a, now) ? "lapsed" : a.status,
-          private: a.discretion !== "open" || isPrivateSession(a.session_id),
-        };
-      });
-  }
-}
+import { randomUUID } from "node:crypto";
+import { localClock } from "../core/conversation-cues.js";
+import { hasCredential } from "./guard.js";
+import { isPrivateSession } from "./memory.js";
+import { lifeSpan } from "./nature.js";
+import { classifyActivity, isExecutable } from "./time/tasks.js";
+import { taskIntent } from "./time/intent.js";
+import { DAY, evidence, parse, similar, text, zonedTime } from "./util.js";
+
+// What she is looking ahead to: promises she made, things she means to do,
+// what others told her is coming, and the dates that come back every year.
+export const ANTICIPATION_KINDS = {
+  promise: "答应的事",
+  plan: "想做的事",
+  event: "别人的安排",
+  date: "每年的日子",
+};
+// How long after its day something still waits to be asked about or done
+// before it quietly counts as missed.
+const GRACE = { event: 3 * DAY, promise: 7 * DAY, plan: 7 * DAY, date: 0 };
+const HORIZON = 400 * DAY;
+const CLOSE = new Set(["done", "missed", "let_go"]);
+
+function row(value) {
+  return value
+    ? {
+        ...value,
+        sources: parse(value.sources, []),
+        closed_sources: parse(value.closed_sources, []),
+      }
+    : null;
+}
+
+export class Anticipations {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  day(time) {
+    return localClock(time, this.mind.timeZone()).local.slice(0, 10);
+  }
+  // A yearly date's next return (or today's), otherwise the one due moment.
+  occurrence(a, now) {
+    if (a.recurrence !== "yearly") return a.due_at;
+    const monthDay = this.day(a.due_at).slice(5);
+    const year = Number(this.day(now).slice(0, 4));
+    for (const y of [year - 1, year, year + 1]) {
+      const at = zonedTime(`${y}-${monthDay}`, this.mind.timeZone());
+      if (at !== null && at + DAY > now) return at;
+    }
+    return a.due_at;
+  }
+  ends(a, due) {
+    return due + (a.due_precision === "time" ? 0 : DAY);
+  }
+  // From the start of the day before.
+  opens(due) {
+    const midnight = zonedTime(this.day(due), this.mind.timeZone());
+    return (midnight ?? due) - DAY;
+  }
+  // Her name for someone, or the name they last used where it was said.
+  who(a) {
+    if (!a.subject) return "";
+    const known = this.mind.bonds.name(a.subject);
+    if (known) return known;
+    const said = parse(
+      this.db
+        .prepare(
+          "SELECT payload FROM core_events WHERE session_id=? AND role='user' AND json_extract(payload,'$.userId')=? ORDER BY seq DESC LIMIT 1",
+        )
+        .get(a.session_id, String(a.subject))?.payload,
+      {},
+    );
+    return said.name || a.subject;
+  }
+  lapsed(a, now) {
+    return (
+      a.recurrence !== "yearly" &&
+      now > this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event)
+    );
+  }
+  // A private promise can be written in her diary. It cannot be carried out
+  // of that room, or into the story she retells everywhere.
+  concealed(a) {
+    return a.discretion !== "open" || isPrivateSession(a.session_id);
+  }
+  // Private rooms whose plans, promises, or dates the diary of `day` would see.
+  privateRooms(day, before = Date.now()) {
+    const nature = this.mind.nature.current(before);
+    const zone = this.mind.timeZone();
+    const span = lifeSpan(nature, day, zone);
+    if (!span || span.start > before) return [];
+    const end = Math.min(before, span.end);
+    const rooms = new Set();
+    for (const a of this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE created<=? AND status!='revoked'",
+      )
+      .all(before)
+      .map(row)) {
+      if (!this.concealed(a) || !this.#onDay(a, span, end)) continue;
+      // The room where it was said may still see that day's diary. A marker
+      // with no room would hide the diary everywhere, including there.
+      rooms.add(a.session_id || `a:${a.id}`);
+    }
+    return [...rooms];
+  }
+  #onDay(a, span, before) {
+    const pending =
+      a.status === "pending" || (a.closed_at != null && a.closed_at > before);
+    if (
+      !pending &&
+      a.closed_at >= span.start &&
+      a.closed_at < span.end &&
+      a.closed_at <= before
+    )
+      return true;
+    if (a.recurrence === "yearly")
+      return this.day(this.occurrence(a, span.start)) === this.day(span.start);
+    if (a.due_at >= span.start && a.due_at < span.end) return true;
+    const lapse = this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event);
+    return pending && lapse >= span.start && lapse < span.end;
+  }
+  revokedContents() {
+    return this.db
+      .prepare(
+        "SELECT content FROM mind_revocations WHERE target_kind='anticipation'",
+      )
+      .all()
+      .map((r) => r.content)
+      .filter(Boolean);
+  }
+  add({
+    kind,
+    subject = null,
+    session = null,
+    content,
+    due,
+    recurrence = "none",
+    discretion = "open",
+    sources = [],
+    origin = "memory",
+    activity = "",
+    time = Date.now(),
+  }) {
+    if (!ANTICIPATION_KINDS[kind]) return { rejected: "类型无效" };
+    const words = text(content, 120);
+    if (!words || hasCredential(words)) return { rejected: "内容无效" };
+    const refs = evidence(sources);
+    if (!refs.length) return { rejected: "缺少来源" };
+    const when = String(due ?? "").trim();
+    const at = zonedTime(when, this.mind.timeZone());
+    if (at === null) return { rejected: "日期无效" };
+    const yearly = kind === "date" || recurrence === "yearly";
+    const precision = /\d{2}:\d{2}$/.test(when) ? "time" : "day";
+    if (
+      !yearly &&
+      (this.ends({ due_precision: precision }, at) <= time - DAY ||
+        at > time + HORIZON)
+    )
+      return { rejected: "日期不在合理范围" };
+    const who = subject ? String(subject) : "";
+    if (
+      this.revokedContents().some((old) =>
+        similar(old, `${who}\n${words}`, 0.75),
+      )
+    )
+      return { rejected: "与撤销过的内容相同" };
+    if (!yearly && ["plan", "promise"].includes(kind)) {
+      const input = {
+          title: words,
+          activity: activity || classifyActivity(words),
+          subject,
+          session,
+          sources: refs,
+        },
+        intent = taskIntent(this.db, input);
+      if (intent.key) {
+        const tracked = this.mind.time?.tasks.links.find(input);
+        const prior = tracked
+          ? this.mind.time.tasks.links
+              .anticipations(tracked)
+              .map((id) => this.get(id))
+              .find((a) => a && a.status !== "revoked")
+          : this.db
+              .prepare(
+                "SELECT * FROM mind_anticipations WHERE kind IN ('plan','promise') AND status='pending' ORDER BY created",
+              )
+              .all()
+              .find(
+                (a) =>
+                  taskIntent(this.db, {
+                    title: a.content,
+                    activity: a.activity || classifyActivity(a.content),
+                    subject: a.subject,
+                    session: a.session_id,
+                    sources: parse(a.sources, []),
+                  }).key === intent.key,
+              );
+        if (tracked || prior) {
+          if (tracked) {
+            this.mind.time.tasks.links.mergeSource(
+              tracked,
+              {
+                sources: refs,
+                kind,
+                subject: who || intent.recipient,
+                dueAt: at,
+                duePrecision: precision,
+                origin,
+              },
+              time,
+            );
+            if (tracked.state === "abandoned")
+              this.mind.time.tasks.links.close(
+                tracked,
+                "原事项已放下，重复整理不能恢复",
+                time,
+              );
+          } else
+            this.db
+              .prepare("UPDATE mind_anticipations SET sources=? WHERE id=?")
+              .run(
+                JSON.stringify(
+                  evidence([...parse(prior.sources, []), ...refs]),
+                ),
+                prior.id,
+              );
+          return {
+            duplicate: prior?.id || tracked.id,
+            task: tracked?.id,
+            suppressed: tracked?.state === "abandoned",
+          };
+        }
+      }
+    }
+    const key = yearly ? this.day(at).slice(5) : this.day(at);
+    const same = this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE status='pending' AND COALESCE(subject,'')=? AND kind=?",
+      )
+      .all(who, kind)
+      .find(
+        (r) =>
+          (yearly ? this.day(r.due_at).slice(5) : this.day(r.due_at)) === key &&
+          similar(r.content, words, 0.6),
+      );
+    if (same) return { duplicate: same.id };
+    const id = randomUUID();
+    this.db
+      .prepare(
+        "INSERT INTO mind_anticipations(id,created,kind,subject,session_id,content,due_at,due_precision,recurrence,discretion,sources,origin,activity) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+      )
+      .run(
+        id,
+        time,
+        kind,
+        who || null,
+        session,
+        words,
+        at,
+        precision,
+        yearly ? "yearly" : "none",
+        ["open", "private", "secret"].includes(discretion)
+          ? discretion
+          : "open",
+        JSON.stringify(refs),
+        origin,
+        kind === "plan" && isExecutable(activity) ? activity : "",
+      );
+    return { id };
+  }
+  get(id) {
+    return row(
+      this.db.prepare("SELECT * FROM mind_anticipations WHERE id=?").get(id),
+    );
+  }
+  // Still open at `now`; something closed later still counts when looking back.
+  pending(now = Date.now()) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE created<=? AND (status='pending' OR (closed_at IS NOT NULL AND closed_at>? AND status!='revoked')) ORDER BY due_at",
+      )
+      .all(now, now)
+      .map(row);
+  }
+  close(id, { status, note = "", sources = [], time = Date.now() } = {}) {
+    if (!CLOSE.has(status)) return false;
+    const a = this.get(id);
+    if (!a || a.status !== "pending" || a.recurrence === "yearly") return false;
+    if (status === "done") {
+      if (
+        ["plan", "promise"].includes(a.kind) &&
+        (a.activity || classifyActivity(a.content) !== "unknown")
+      )
+        this.mind.time?.tasks.sync(time);
+      const task = this.db
+        .prepare(
+          "SELECT state,share_state FROM mind_time_tasks WHERE anticipation_id=?",
+        )
+        .get(id);
+      if (
+        task &&
+        (task.state !== "done" || !["none", "sent"].includes(task.share_state))
+      )
+        return false;
+    }
+    return (
+      this.db
+        .prepare(
+          "UPDATE mind_anticipations SET status=?,closed_at=?,closed_note=?,closed_sources=? WHERE id=? AND status='pending'",
+        )
+        .run(
+          status,
+          time,
+          text(note, 120),
+          JSON.stringify(evidence(sources)),
+          id,
+        ).changes > 0
+    );
+  }
+  revoke(id, reason = "") {
+    const a = this.get(id);
+    if (!a) throw Error("约定不存在");
+    this.db
+      .prepare(
+        "UPDATE mind_anticipations SET status='revoked',closed_at=?,closed_note=? WHERE id=?",
+      )
+      .run(Date.now(), text(reason, 120), id);
+    return `${a.subject || ""}\n${a.content}`;
+  }
+  relative(due, now, precision = "day") {
+    const zone = this.mind.timeZone();
+    const at = (t) =>
+      Date.parse(`${localClock(t, zone).local.slice(0, 10)}T00:00:00Z`);
+    const days = Math.round((at(due) - at(now)) / DAY);
+    const clock =
+      precision === "time" ? ` ${localClock(due, zone).local.slice(11)}` : "";
+    const named = {
+      0: "今天",
+      1: "明天",
+      2: "后天",
+      [-1]: "昨天",
+      [-2]: "前天",
+    };
+    if (named[days] !== undefined) return named[days] + clock;
+    return days > 0 ? `${days} 天后` : `${-days} 天前`;
+  }
+  label(a, due, now) {
+    const who = this.who(a);
+    const when = this.relative(due, now, a.due_precision);
+    if (a.kind === "promise") {
+      const task = this.db
+        .prepare(
+          "SELECT state,share_state,checkpoint FROM mind_time_tasks WHERE anticipation_id=?",
+        )
+        .get(a.id);
+      const progress =
+        task?.state === "done" && task.share_state !== "sent"
+          ? "作品完成，尚未交付"
+          : task?.state === "doing"
+            ? "正在做"
+            : parse(task?.checkpoint, {}).workId
+              ? "已有草稿，尚未完成"
+              : "还没做";
+      return `我答应${who ? `${who}` : ""}：${a.content}（${when}${a.status === "pending" ? "，" + progress : ""}）`;
+    }
+    if (a.kind === "plan") return `我打算：${a.content}（${when}）`;
+    if (a.kind === "event")
+      return `${who ? `${who}计划：` : "有人计划："}${a.content}（${when}，结果未确认）`;
+    return `${who ? `${who}：` : ""}${a.content}（${when}）`;
+  }
+  // Near enough to matter in a conversation: from the day before until a few
+  // days after, and only where it belongs.
+  upcoming({ now = Date.now(), people = [], session = "", limit = 3 } = {}) {
+    const here = new Set(session ? this.mind.memory.scopes(session) : []);
+    const present = new Set(people.map(String));
+    const out = [];
+    for (const a of this.pending(now)) {
+      const due = this.occurrence(a, now);
+      const after =
+        a.recurrence === "yearly" ? 0 : (GRACE[a.kind] ?? GRACE.event);
+      if (now < this.opens(due) || now >= this.ends(a, due) + after) continue;
+      // A plan by someone else in this room belongs to that person. Its
+      // presence in the same group must not make it A's plan when B said it.
+      const relevant = a.subject
+        ? present.has(String(a.subject))
+        : a.session_id === session || a.kind === "plan";
+      if (!relevant) continue;
+      const local = here.has(a.session_id);
+      if (a.discretion !== "open" && !local) continue;
+      out.push({ id: a.id, due, text: this.label(a, due, now) });
+      if (out.length >= limit) break;
+    }
+    return out;
+  }
+  // What she might think about when alone: due soon, just past, or quietly
+  // missed within the last week.
+  // What is still ahead comes first, soonest first. Then what was due but still
+  // waits (inside its grace), then what already lapsed; both the most recent
+  // first, so a week-old plan of someone else does not take the places from
+  // what is near now.
+  due({ now = Date.now(), limit = 5, shareable = false } = {}) {
+    const found = [];
+    for (const a of this.pending(now)) {
+      if (shareable && this.concealed(a)) continue;
+      const due = this.occurrence(a, now);
+      const after =
+        a.recurrence === "yearly"
+          ? 0
+          : (GRACE[a.kind] ?? GRACE.event) + 7 * DAY;
+      if (now < this.opens(due) || now >= this.ends(a, due) + after) continue;
+      const lapsed = this.lapsed(a, now);
+      // 0: its day has not passed yet; 1: due, still inside the grace;
+      // 2: already lapsed.
+      const rank = lapsed ? 2 : this.ends(a, due) <= now ? 1 : 0;
+      found.push({
+        due,
+        rank,
+        item: {
+          ref: `a:${a.id}`,
+          kind: ANTICIPATION_KINDS[a.kind],
+          ...(a.subject ? { who: this.who(a), userId: a.subject } : {}),
+          content: a.content,
+          when: this.relative(due, now, a.due_precision),
+          ...(lapsed ? { lapsed: true } : {}),
+          ...(a.recurrence === "yearly" ? { yearly: true } : {}),
+        },
+      });
+    }
+    return found
+      .sort(
+        (a, b) => a.rank - b.rank || (a.rank ? b.due - a.due : a.due - b.due),
+      )
+      .slice(0, limit)
+      .map((entry) => entry.item);
+  }
+  // Something she was looking ahead to has come close, or just passed.
+  newlyDue(since, now = Date.now()) {
+    return this.pending(now).some((a) => {
+      const due = this.occurrence(a, now);
+      const edges = [this.opens(due), this.ends(a, due)];
+      return edges.some((edge) => edge > since && edge <= now);
+    });
+  }
+  // The day's promises kept and missed, and the dates that fall on it.
+  today({ start, end, shareable = false }) {
+    const keep = (a) => !shareable || !this.concealed(a);
+    const closed = this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations WHERE closed_at>=? AND closed_at<? AND status IN ('done','missed','let_go') ORDER BY closed_at",
+      )
+      .all(start, end)
+      .map(row)
+      .filter(keep);
+    const lapsedToday = this.pending(end).filter((a) => {
+      if (!keep(a) || a.recurrence === "yearly") return false;
+      const at = this.ends(a, a.due_at) + (GRACE[a.kind] ?? GRACE.event);
+      return at >= start && at < end;
+    });
+    const line = (a) => this.label(a, this.occurrence(a, start), start);
+    const byStatus = (status) =>
+      closed.filter((a) => a.status === status).map(line);
+    return {
+      kept: byStatus("done"),
+      missed: [...byStatus("missed"), ...lapsedToday.map(line)],
+      letGo: byStatus("let_go"),
+      dates: this.pending(end)
+        .filter(
+          (a) =>
+            keep(a) &&
+            a.recurrence === "yearly" &&
+            this.day(this.occurrence(a, start)) === this.day(start),
+        )
+        .map(line),
+      dueToday: this.pending(end)
+        .filter(
+          (a) =>
+            keep(a) &&
+            a.recurrence !== "yearly" &&
+            a.due_at >= start &&
+            a.due_at < end,
+        )
+        .map(line),
+    };
+  }
+  list({ now = Date.now(), limit = 100 } = {}) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_anticipations ORDER BY CASE status WHEN 'pending' THEN 0 ELSE 1 END, due_at LIMIT ?",
+      )
+      .all(limit)
+      .map(row)
+      .map((a) => {
+        const due = this.occurrence(a, now);
+        return {
+          ...a,
+          name: this.who(a),
+          occurrence: due,
+          when: this.relative(due, now, a.due_precision),
+          state:
+            a.status === "pending" && this.lapsed(a, now) ? "lapsed" : a.status,
+          private: a.discretion !== "open" || isPrivateSession(a.session_id),
+        };
+      });
+  }
+}