luckytri 1.0.8 → 1.1.0

package/server/mind/day-planner.js

@@ -9,7 +9,18 @@ import {
 } from "./time/availability.js";
 import { rhythmPhase } from "./nature.js";
 import { isExecutable, pluginAvailable, withActivities } from "./time/kinds.js";
+import { providerWaitMs } from "../core/backoff.js";
 const MINUTE = 60000;
+// A task that came back without a plan waits longer each time. Asking again
+// every ten minutes spent hundreds of calls a day on the same answer.
+export const DAY_PLAN_SCHEDULE = [
+  10 * MINUTE,
+  30 * MINUTE,
+  2 * 60 * MINUTE,
+  6 * 60 * MINUTE,
+  12 * 60 * MINUTE,
+];
+const planKey = (id) => `day-plan:${id}`;
 
 export function chosenSlot(value, life, now, requestedAt = now) {
   const at = value.startAt
@@ -126,7 +137,9 @@ export class DayPlanner {
         (t) =>
           (!primary || t.priority > primary.priority) &&
           this.needs(t, now) &&
-          (state.requested || now - (attempts[t.id] || 0) >= 10 * MINUTE),
+          (state.requested ||
+            (now - (attempts[t.id] || 0) >= 10 * MINUTE &&
+              life.mind.backoff.ready(planKey(t.id), now))),
       )
       .sort((a, b) => time.tasks.score(b, now) - time.tasks.score(a, now));
     const task = tasks.find((t) => !unsupportedAction(t)) || tasks[0];
@@ -155,7 +168,8 @@ export class DayPlanner {
         trace = life.repo.trace("__mind__", "activity"),
         runId = life.run("day-plan", "想具体做什么、几点开始和做多久");
       let status = "error",
-        reason = "";
+        reason = "",
+        failure = null;
       try {
         const projects = time.works
           .projects({ limit: 20 })
@@ -275,11 +289,34 @@ export class DayPlanner {
           const project = projects.find(
             (p) => p.id === answer.projectId && p.kind === activity,
           );
+          // The chosen time may already be taken. Move to the next free
+          // stretch she is awake for, instead of asking the model again.
+          const wanted = Math.max(slot.startAt, task.ready_at);
+          const startAt = time.tasks.freeStart(
+            task.id,
+            wanted,
+            slot.durationMinutes,
+            life.now(),
+            {
+              acceptable: (at) =>
+                rhythmPhase(
+                  life.mind.nature.current(at),
+                  at,
+                  life.mind.timeZone(),
+                ).key !== "asleep",
+            },
+          );
+          if (startAt === null) throw Error("一周内没有空出的时间段");
+          if (startAt !== wanted)
+            slot.reason = text(
+              `${slot.reason}（原定时间已有安排，顺延到 ${localClock(startAt, life.mind.timeZone()).local}）`,
+              240,
+            );
           time.tasks.arrange(
             task.id,
             {
               ...slot,
-              startAt: Math.max(slot.startAt, task.ready_at),
+              startAt,
               activity,
               title:
                 task.kind === "promise" && task.activity !== "unknown"
@@ -296,8 +333,20 @@ export class DayPlanner {
       } catch (error) {
         reason = text(error.message, 160);
         trace.error = reason;
+        failure = error;
         return { status: "error", reason };
       } finally {
+        if (status === "planned") life.mind.backoff.succeed(planKey(task.id));
+        else if (["waiting", "resting", "error"].includes(status))
+          life.mind.backoff.fail(
+            planKey(task.id),
+            failure || reason || status,
+            life.now(),
+            {
+              schedule: DAY_PLAN_SCHEDULE,
+              minimumMs: providerWaitMs(failure),
+            },
+          );
         this.working = false;
         life.chat.finishQuietly(
           trace,

package/server/mind/episodes.js

@@ -0,0 +1,242 @@
+import { randomUUID } from "node:crypto";
+import { applySpeakerNames } from "../core/speaker-names.js";
+import { elapsedLabel } from "./clock.js";
+import { secretRequest } from "./guard.js";
+import { isPrivateSession } from "./memory.js";
+import { grounded } from "./salience.js";
+import { hasCredential, parse, text, zonedTime } from "./util.js";
+
+export const EPISODE_STATUS = new Set(["open", "resolved", "abandoned"]);
+const RELATIONS = new Set(["continues", "resolves"]);
+
+// An affair from its start to how it stands now: an interview that was
+// coming, then happened, then had a result. Each step is its own row in the
+// same thread, citing the messages it rests on, so the past is never
+// rewritten and recall can tell what happened, what changed and what is
+// still open.
+export class Episodes {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  get(id) {
+    return this.db.prepare("SELECT * FROM mind_episodes WHERE id=?").get(id);
+  }
+  thread(threadId, before = Number.MAX_SAFE_INTEGER) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_episodes WHERE thread_id=? AND created<=? ORDER BY created,rowid",
+      )
+      .all(threadId, before);
+  }
+  latest(threadId, before = Number.MAX_SAFE_INTEGER) {
+    return this.thread(threadId, before).at(-1) || null;
+  }
+  visible(row, session) {
+    if (row.discretion === "open") return true;
+    return this.mind.memory.scopes(session).includes(row.session_id);
+  }
+  // Threads still open that concern these people or this room, newest
+  // first, as seen at `now`.
+  open({ session, people = [], now = Date.now(), limit = 6 } = {}) {
+    const rows = this.db
+      .prepare(
+        `SELECT e.* FROM mind_episodes e JOIN (
+           SELECT thread_id,MAX(created) last FROM mind_episodes WHERE created<=? GROUP BY thread_id
+         ) l ON l.thread_id=e.thread_id AND l.last=e.created
+         WHERE e.status='open' ORDER BY e.created DESC LIMIT 200`,
+      )
+      .all(now);
+    const who = new Set(people.map(String));
+    return rows
+      .filter((row) => this.visible(row, session))
+      .filter(
+        (row) =>
+          row.session_id === session ||
+          parse(row.participants, []).some((id) => who.has(String(id))),
+      )
+      .slice(0, limit);
+  }
+  due(now = Date.now(), limit = 4) {
+    return this.db
+      .prepare(
+        `SELECT e.* FROM mind_episodes e JOIN (
+           SELECT thread_id,MAX(created) last FROM mind_episodes WHERE created<=? GROUP BY thread_id
+         ) l ON l.thread_id=e.thread_id AND l.last=e.created
+         WHERE e.status='open' AND e.follow_up_at>0 AND e.follow_up_at<=?
+         ORDER BY e.follow_up_at LIMIT ?`,
+      )
+      .all(now, now, limit);
+  }
+  // Open threads offered to the consolidation model so a new step can
+  // continue or resolve one instead of starting a duplicate.
+  candidates(session, block, now = Date.now()) {
+    const people = [
+      ...new Set(
+        block.filter((m) => m.role === "user").map((m) => String(m.userId)),
+      ),
+    ];
+    const refs = new Map();
+    const list = this.open({ session, people, now, limit: 8 }).map((row, i) => {
+      const ref = `e${i + 1}`;
+      refs.set(ref, row);
+      return {
+        ref,
+        title: row.title,
+        sofar: text(row.outcome || row.content, 120),
+        since: elapsedLabel(
+          row.happened_start || row.created,
+          now,
+          this.mind.timeZone(),
+        ),
+      };
+    });
+    return { list, refs };
+  }
+  // Writes what the consolidation model reported, keeping only steps whose
+  // words were actually said in the cited messages of this stretch.
+  record(
+    list,
+    { block, session, refs = new Map(), names, privateChat, now, runId = null },
+  ) {
+    const written = [];
+    const bySeq = new Map(block.map((m) => [m.seq, m]));
+    for (const raw of (Array.isArray(list) ? list : []).slice(0, 6)) {
+      if (
+        !raw ||
+        typeof raw.title !== "string" ||
+        typeof raw.content !== "string"
+      )
+        continue;
+      const cited = (Array.isArray(raw.sources) ? raw.sources : [])
+        .map(Number)
+        .map((seq) => bySeq.get(seq))
+        .filter(Boolean);
+      if (!cited.length || cited.some((m) => m.artifact)) continue;
+      const words = cited.map((m) => m.text || "");
+      const content = text(raw.content, 300);
+      const outcome = text(raw.outcome, 160);
+      if (
+        hasCredential(`${raw.title}${content}${outcome}`) ||
+        !grounded(content, words) ||
+        (outcome && !grounded(outcome, words))
+      )
+        continue;
+      const status = EPISODE_STATUS.has(raw.status) ? raw.status : "open";
+      const relation = RELATIONS.has(raw.relation)
+        ? raw.relation
+        : status === "resolved"
+          ? "resolves"
+          : "continues";
+      const previous = raw.continues ? refs.get(String(raw.continues)) : null;
+      const speakers = new Set(
+        cited.filter((m) => m.role === "user").map((m) => String(m.userId)),
+      );
+      const participants = [
+        ...new Set([
+          ...speakers,
+          ...(Array.isArray(raw.participants) ? raw.participants : [])
+            .map(String)
+            .filter((id) => block.some((m) => String(m.userId) === id)),
+        ]),
+      ];
+      const quiet = block.some(
+        (m) =>
+          m.role === "user" &&
+          m.seq <= Math.max(...cited.map((c) => c.seq)) &&
+          secretRequest(m.text || ""),
+      );
+      const discretion =
+        quiet || previous?.discretion === "secret"
+          ? "secret"
+          : privateChat || previous?.discretion === "private"
+            ? "private"
+            : "open";
+      const follow = raw.followUp
+        ? zonedTime(String(raw.followUp), this.mind.timeZone())
+        : null;
+      const id = randomUUID();
+      const thread = previous?.thread_id || id;
+      this.db
+        .prepare(
+          `INSERT INTO mind_episodes(id,thread_id,created,session_id,title,content,outcome,status,participants,
+           happened_start,happened_end,follow_up_at,basis,importance,discretion,sources,run_id)
+           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+        )
+        .run(
+          id,
+          thread,
+          now,
+          previous?.session_id && previous.discretion !== "open"
+            ? previous.session_id
+            : session,
+          text(applySpeakerNames(raw.title, names), 40),
+          applySpeakerNames(content, names),
+          applySpeakerNames(outcome, names),
+          status,
+          JSON.stringify(participants),
+          previous?.happened_start || Math.min(...cited.map((m) => m.time)),
+          status === "open" ? null : Math.max(...cited.map((m) => m.time)),
+          status === "open" && Number.isFinite(follow) && follow > now
+            ? follow
+            : null,
+          raw.basis === "told" ? "stated" : "witnessed",
+          Math.min(1, Math.max(0, Number(raw.importance) || 0.5)),
+          discretion,
+          JSON.stringify(cited.map((m) => m.seq)),
+          runId,
+        );
+      if (previous)
+        this.db
+          .prepare(
+            "INSERT OR IGNORE INTO mind_links(from_id,to_id,relation,created,sources) VALUES (?,?,?,?,?)",
+          )
+          .run(
+            `episode:${id}`,
+            `episode:${previous.id}`,
+            relation,
+            now,
+            JSON.stringify(cited.map((m) => m.seq)),
+          );
+      this.mind.recall?.sync("episode", id);
+      written.push(id);
+    }
+    return written;
+  }
+  // One remembered affair, told as it went and as it stands: the beginning,
+  // what changed and where it is now. A private thread stays private.
+  recollection(row, session, now = Date.now()) {
+    const steps = this.thread(row.thread_id, now);
+    const last = steps.at(-1) || row;
+    const first = steps[0] || row;
+    const zone = this.mind.timeZone();
+    const local = this.mind.memory.scopes(session).includes(last.session_id);
+    return {
+      kind: "episode",
+      title: last.title,
+      began: elapsedLabel(first.happened_start || first.created, now, zone),
+      ...(steps.length > 1
+        ? {
+            sofar: steps
+              .slice(0, -1)
+              .slice(-2)
+              .map((s) => text(s.outcome || s.content, 60)),
+          }
+        : {}),
+      now: text(last.outcome || last.content, 120),
+      status:
+        last.status === "open"
+          ? last.follow_up_at && last.follow_up_at <= now
+            ? "还没结果，说好的时间已经过了"
+            : "还没结束"
+          : last.status === "resolved"
+            ? "已经有结果"
+            : "后来放下了",
+      updated: elapsedLabel(last.created, now, zone),
+      ...(last.basis === "stated" ? { basis: "对方告诉你的" } : {}),
+      ...(!local && isPrivateSession(last.session_id)
+        ? { discretion: "私下知道的，不要当众说出口，也不要说出从哪听来" }
+        : {}),
+    };
+  }
+}

package/server/mind/expression-grounding.js

@@ -1,21 +1,24 @@
-export function claimsLivedAction(content) {
-  return String(content || "")
-    .split(/[。！？\n]/)
-    .some(
-      (clause) =>
-        !/想|打算|准备|希望|假如|设想|如果/.test(clause) &&
-        /(?:刚才|刚刚|今天|这次|然后|真的|已经)[^。！？]{0,25}(?:读了|读上|读完|翻开|翻出来|写完|完成了|打开了|开始读|动手了)/.test(
-          clause,
-        ),
-    );
-}
-
-export function claimsSharedHistory(content) {
-  return /(?:之前|上次|早些时候)[^。！？\n]{0,25}(?:他|她|对方|那个人|你)[^。！？\n]{0,20}(?:说过|聊过|看过|读过|回话|私下)|(?:他|她|对方|那个人|你)[^。！？\n]{0,15}(?:之前|上次|读过|看过|说过)/.test(
-    String(content || ""),
-  );
-}
-
-export const EXPRESSION_GROUNDING = `核对一个准备保存的自我念头是否把愿望写成行动，或把别人的话题误认成共同经历。只输出JSON。
-candidate只是草稿，不是事实。notes/self是过去的想法、愿望或理解；它们可以支持新的感受和看法，不能单独证明这次真的开始、读完或做完。actions/currentLife是实际活动记录。sources只表示引用了哪里，不自动证明动作。按实际记录核对这次声称新做过的具体动作和对象；不能用无关作品或一条待办证明完成。声称共同经历时，还须核对实际参与者和各自说过的话；在别处读到另一人的讨论不证明当前对象参与过。自己的新想法、偏好、假设、打算可以没有执行记录，也不需要已采取外部行动。只指出确实无依据的新经历与归属，不评文风。
-输出 {"ok":true或false,"reason":"具体哪项新经历有或没有实际记录"}。`;
+export function claimsLivedAction(content) {
+  return String(content || "")
+    .split(/[。！？\n]/)
+    .some(
+      (clause) =>
+        !/想|打算|准备|希望|假如|设想|如果/.test(clause) &&
+        (/(?:刚才|刚刚|今天|这次|然后|真的|已经)[^。！？]{0,25}(?:读了|读上|读完|读[一二两三几\d]+[段页章节遍]|坐下来读|翻开|翻出来|写完|完成了|打开了|开始读|动手了)/.test(
+          clause,
+        ) ||
+          /我(?:自己)?[^。！？]{0,10}(?:读上了|开始读了|翻开了|完成了|写完了)/.test(
+            clause,
+          )),
+    );
+}
+
+export function claimsSharedHistory(content) {
+  return /(?:之前|上次|早些时候)[^。！？\n]{0,25}(?:他|她|对方|那个人|你)[^。！？\n]{0,20}(?:说过|聊过|看过|读过|回话|私下)|(?:他|她|对方|那个人|你)[^。！？\n]{0,15}(?:之前|上次|读过|看过|说过)/.test(
+    String(content || ""),
+  );
+}
+
+export const EXPRESSION_GROUNDING = `核对一个准备保存的自我念头是否把愿望写成行动，或把别人的话题误认成共同经历。只输出JSON。
+candidate只是草稿，不是事实。notes/self是过去的想法、愿望或理解；它们可以支持新的感受和看法，不能单独证明这次真的开始、读完或做完。actions/currentLife是实际活动记录。sources只表示引用了哪里，不自动证明动作。按实际记录核对这次声称新做过的具体动作和对象；不能用无关作品或一条待办证明完成。声称共同经历时，还须核对实际参与者和各自说过的话；在别处读到另一人的讨论不证明当前对象参与过。自己的新想法、偏好、假设、打算可以没有执行记录，也不需要已采取外部行动。只指出确实无依据的新经历与归属，不评文风。
+输出 {"ok":true或false,"reason":"具体哪项新经历有或没有实际记录"}。`;

package/server/mind/index.js

@@ -22,6 +22,10 @@ import { innerView } from "./view.js";
 import { Senses } from "./senses.js";
 import { Observations } from "./observations.js";
 import { clamp, dayKey, parse, text } from "./util.js";
+import { Backoff } from "../core/backoff.js";
+import { EmbeddingService } from "../core/embedding.js";
+import { Recall } from "./recall/index.js";
+import { Episodes } from "./episodes.js";
 
 // The wish a day's snapshot says she was living. Older snapshots did not
 // store it; those fall back to her own-life threads from that day.
@@ -86,11 +90,13 @@ const TURN_CHANGES = new Set(
 // One of her, across every conversation. Sessions only say where something
 // happened; they are no longer walls between parts of her.
 export class Mind {
-  constructor(repo, { models } = {}) {
+  constructor(repo, { models, now = () => Date.now() } = {}) {
     this.repo = repo;
     this.db = repo.db;
     this.store = repo.store;
     migrateMind(this.db, this.store);
+    this.backoff = new Backoff(this.db);
+    this.embedding = new EmbeddingService(repo, models, { now });
     this.db.exec(
       "CREATE INDEX IF NOT EXISTS core_events_time ON core_events(time)",
     );
@@ -113,6 +119,8 @@ export class Mind {
     this.time = new TimeSystem(this);
     this.senses = new Senses();
     this.observations = new Observations(this);
+    this.episodes = new Episodes(this);
+    this.recall = new Recall(this);
     this.body = () => [];
     this.days.reconcile();
   }
@@ -120,7 +128,7 @@ export class Mind {
     return this.repo.config("life", {})?.timeZone || "Asia/Shanghai";
   }
   view(options) {
-    return innerView(this, options);
+    return this.meetings.memo(() => innerView(this, options));
   }
   // The whole system is one body she can read: what is connected, and
   // whether each plugin is on. The studio shows the same state.
@@ -361,6 +369,9 @@ export class Mind {
     } else if (kind === "observation") {
       tomb(this.observations.revoke(id));
     } else throw Error("不能撤销这类内容");
+    // A withdrawn memory is no longer searchable either.
+    if (["self", "meeting", "thought", "anticipation"].includes(kind))
+      this.recall.sync(kind, id);
     this.store.revision++;
   }
   revocations(limit = 100) {