luckytri 1.0.0

package/server/mind/conversation-origin.js

@@ -0,0 +1,175 @@
+import {
+  parseSessionKey,
+  scopedSessionAliases,
+} from "../channels/session-key.js";
+import { evidence, parse } from "./util.js";
+
+// A public memory may be recalled everywhere. That does not turn everyone
+// into a participant. Retellings retain the original speakers and add no one.
+export function conversationOrigin(db, sources, before = Date.now()) {
+  const queue = evidence(sources),
+    seen = new Set(),
+    rooms = new Map();
+  let incomplete = false;
+  const event = db.prepare(
+    "SELECT seq,session_id,time,role,payload FROM core_events WHERE seq=? AND time<=? AND COALESCE(json_extract(payload,'$.simulated'),0)=0 AND seq NOT IN (SELECT seq FROM mind_unlived)",
+  );
+  const take = (row) => {
+    if (!row) return;
+    let identity;
+    try {
+      identity = parseSessionKey(row.session_id);
+    } catch {
+      return;
+    }
+    if (!rooms.has(row.session_id))
+      rooms.set(row.session_id, {
+        sessionId: row.session_id,
+        channel: identity.channel,
+        kind: identity.kind,
+        people: new Map(),
+      });
+    const room = rooms.get(row.session_id),
+      payload = parse(row.payload, {});
+    if (row.role === "user" && payload.userId && payload.userId !== "bot")
+      room.people.set(String(payload.userId), {
+        id: String(payload.userId),
+        name: payload.name || "这位参与者",
+      });
+    if (row.role === "assistant") {
+      // Confirmed replies credit their actual addressees, never nearby members.
+      for (const seq of (Array.isArray(payload.replyTargetIds)
+        ? payload.replyTargetIds
+        : []
+      ).slice(0, 24)) {
+        const target = event.get(Number(seq), Math.min(before, row.time));
+        if (!target) incomplete = true;
+        if (target?.role === "user" && target.session_id === row.session_id)
+          take(target);
+      }
+    }
+  };
+  for (let cursor = 0; cursor < queue.length; cursor++) {
+    if (seen.size >= 512)
+      return { kind: "conversation", rooms: [], incomplete: true };
+    const ref = queue[cursor];
+    if (seen.has(ref)) continue;
+    seen.add(ref);
+    const kind = ref[0],
+      id = ref.slice(2);
+    if (kind === "m") {
+      const row = event.get(Number(id), before);
+      if (!row) incomplete = true;
+      take(row);
+      continue;
+    }
+    // Reading and her own executed activities are hers to introduce. Their
+    // original motivation does not make the finished work someone else's chat.
+    let rows = [];
+    if (kind === "t")
+      rows = db
+        .prepare(
+          "SELECT sources,parent_id FROM mind_thoughts WHERE id=? AND created<=? AND hidden=0",
+        )
+        .all(id, before);
+    else if (kind === "s")
+      rows = db
+        .prepare(
+          "SELECT sources FROM mind_self WHERE thread=? AND created<=? AND thread NOT IN (SELECT target_id FROM mind_revocations WHERE target_kind='self')",
+        )
+        .all(id, before);
+    else if (kind === "g")
+      rows = db
+        .prepare(
+          "SELECT sources FROM mind_meetings WHERE id=? AND created<=? AND id NOT IN (SELECT target_id FROM mind_revocations WHERE target_kind='meeting')",
+        )
+        .all(id, before);
+    else if (kind === "a")
+      rows = db
+        .prepare(
+          "SELECT sources FROM mind_anticipations WHERE id=? AND created<=?",
+        )
+        .all(id, before);
+    else if (kind === "d")
+      rows = db
+        .prepare("SELECT sources FROM mind_diary WHERE day=? AND created<=?")
+        .all(id, before);
+    if (["t", "s", "g", "a", "d"].includes(kind) && !rows.length)
+      incomplete = true;
+    for (const row of rows) {
+      queue.push(...evidence(parse(row.sources, [])));
+      if (row.parent_id) queue.push("t:" + row.parent_id);
+    }
+  }
+  return {
+    kind: rooms.size ? "conversation" : "own",
+    rooms: [...rooms.values()].map((room) => ({
+      ...room,
+      people: [...room.people.values()],
+    })),
+    incomplete,
+  };
+}
+
+export function originSummary(origin) {
+  return {
+    ...origin,
+    rooms: origin.rooms
+      .slice(0, 6)
+      .map((room) => ({ ...room, people: room.people.slice(0, 8) })),
+  };
+}
+
+export function initiativeAudience(mind, thought, session, now = Date.now()) {
+  const sources = evidence(thought?.sources || []),
+    before = Math.min(now, thought?.created || now);
+  const origin = conversationOrigin(mind.db, sources, before);
+  if (!mind.meetings.stays({ sources }, session, before))
+    return {
+      allowed: false,
+      shared: false,
+      origin,
+      reason: "这份想法含有其他会话的私下来源，不能在这里继续",
+    };
+  if (origin.incomplete)
+    return {
+      allowed: false,
+      shared: false,
+      origin,
+      reason: "话题来源缺失、已撤销或过长，参与者尚未核实",
+    };
+  if (!origin.rooms.length)
+    return { allowed: true, shared: false, origin, mode: "new_topic" };
+  let destination;
+  try {
+    destination = parseSessionKey(session);
+  } catch {
+    return {
+      allowed: false,
+      shared: false,
+      origin,
+      reason: "主动交流对象不明确",
+    };
+  }
+  const aliases = new Set(scopedSessionAliases(mind.db, session));
+  const shared = origin.rooms.some(
+    (room) =>
+      room.channel === destination.channel &&
+      (destination.kind === "private"
+        ? room.people.some((person) => person.id === destination.nativeId) ||
+          (room.kind === "private" && aliases.has(room.sessionId))
+        : aliases.has(room.sessionId)),
+  );
+  return {
+    allowed: true,
+    shared,
+    origin,
+    mode: shared ? "continuation" : "new_topic",
+    ...(!shared
+      ? {
+          guidance:
+            "对方未参与原话题。由她判断是否值得分享、是否适合这个人；值得就自然开启新话题并给必要背景，不能当成之前共同聊过、共同项目或对方的约定。也可以选择不聊。",
+        }
+      : {}),
+  };
+}

package/server/mind/day-planner.js

@@ -0,0 +1,324 @@
+import { withFallback } from "../core/model-manager.js";
+import { prompts, replyPrompt } from "../core/persona-manager.js";
+import { localClock } from "../core/conversation-cues.js";
+import { evidence, parse, text, hasCredential, zonedTime } from "./util.js";
+import {
+  executionBlock,
+  unsupportedAction,
+  gameName,
+} from "./time/availability.js";
+import { rhythmPhase } from "./nature.js";
+import { isExecutable, pluginAvailable, withActivities } from "./time/kinds.js";
+const MINUTE = 60000;
+
+export function chosenSlot(value, life, now, requestedAt = now) {
+  const at = value.startAt
+    ? zonedTime(value.startAt, life.mind.timeZone())
+    : now +
+      (Number.isFinite(value.startInMinutes) ? value.startInMinutes : 0) *
+        MINUTE;
+  const minutes = value.durationMinutes;
+  if (
+    !Number.isFinite(at) ||
+    at < requestedAt - MINUTE ||
+    at > now + 7 * 86400000
+  )
+    throw Error("需要选定有效的开始时间");
+  if (!Number.isInteger(minutes) || minutes < 5 || minutes > 240)
+    throw Error("需要选定 5 至 240 分钟的投入时间");
+  const start = Math.max(now, at);
+  if (
+    rhythmPhase(life.mind.nature.current(now), start, life.mind.timeZone())
+      .key === "asleep"
+  )
+    throw Error("所选开始时间在睡眠安排中，需要重新选择");
+  return {
+    startAt: start,
+    durationMinutes: minutes,
+    reason: text(value.reason, 240) || "自己决定先做这一段",
+  };
+}
+
+export class DayPlanner {
+  constructor(life) {
+    this.life = life;
+    this.db = life.db;
+  }
+  state() {
+    return this.life.repo.config("day-planner", {});
+  }
+  request() {
+    this.life.repo.saveConfig("day-planner", {
+      ...this.state(),
+      requested: true,
+    });
+    return { queued: true };
+  }
+  needs(task, now) {
+    if (
+      ["done", "abandoned", "doing"].includes(task.state) ||
+      task.lease ||
+      !this.life.mind.time.allowed(task, now)
+    )
+      return false;
+    if (task.state === "paused" && task.next_step >= Number.MAX_SAFE_INTEGER)
+      return false;
+    const time = this.life.mind.time,
+      slot = task.checkpoint.schedule;
+    return (
+      task.activity === "unknown" ||
+      (task.activity === "game" && !gameName(time, task)) ||
+      !slot?.chosenAt ||
+      (slot.endedAt <= now && !task.checkpoint.pendingStep) ||
+      task.checkpoint.reschedule
+    );
+  }
+  context(task, now) {
+    const roots = evidence(task.sources),
+      messages = [];
+    for (const ref of roots.filter((r) => r.startsWith("m:")).slice(-6)) {
+      const row = this.db
+        .prepare(
+          "SELECT seq,session_id,payload FROM core_events WHERE seq=? AND time<=? AND seq NOT IN (SELECT seq FROM mind_unlived)",
+        )
+        .get(Number(ref.slice(2)), now);
+      if (!row || (task.session_id && task.session_id !== row.session_id))
+        continue;
+      const m = parse(row.payload, {});
+      if (m.simulated || m.artifact) continue;
+      const prior = this.db
+        .prepare(
+          "SELECT seq,role,payload FROM core_events WHERE session_id=? AND seq<? AND time<=? AND seq NOT IN (SELECT seq FROM mind_unlived) AND COALESCE(json_extract(payload,'$.simulated'),0)=0 ORDER BY seq DESC LIMIT 2",
+        )
+        .all(row.session_id, row.seq, now)
+        .reverse();
+      messages.push({
+        ref,
+        text: text(m.text, 500),
+        prior: prior.map((r) => ({
+          role: r.role,
+          text: text(parse(r.payload, {}).text, 240),
+        })),
+      });
+    }
+    return messages;
+  }
+  async run(now = this.life.now()) {
+    const life = this.life,
+      time = life.mind.time;
+    const primary = time.primary();
+    if (
+      this.disabledForTest ||
+      life.closed ||
+      life.busy ||
+      primary?.lease ||
+      time.attention.activityBusy ||
+      !life.settings().solitude ||
+      life.repo.store.settings().demo ||
+      life.phase(now).key === "asleep"
+    )
+      return null;
+    const state = this.state(),
+      attempts = state.attempts || {};
+    const tasks = time.tasks
+      .list({ limit: 100 })
+      .filter(
+        (t) =>
+          (!primary || t.priority > primary.priority) &&
+          this.needs(t, now) &&
+          (state.requested || now - (attempts[t.id] || 0) >= 10 * MINUTE),
+      )
+      .sort((a, b) => time.tasks.score(b, now) - time.tasks.score(a, now));
+    const task = tasks.find((t) => !unsupportedAction(t)) || tasks[0];
+    if (!task) return null;
+    const unsupported = unsupportedAction(task);
+    if (unsupported) {
+      if (task.wait_reason !== unsupported) {
+        time.tasks.wait(task, unsupported, Number.MAX_SAFE_INTEGER, now);
+        time.event(task.id, "capability-wait", unsupported, {}, now);
+      }
+      this.mark(task.id, now);
+      return null;
+    }
+    if (!life.mind.budget.allows("inner", now)) return null;
+    let profile;
+    try {
+      profile = life.profile();
+    } catch {
+      return null;
+    }
+    return time.attention.activity(async () => {
+      this.mark(task.id, now);
+      this.working = true;
+      const revision = task.revision,
+        version = life.mind.nature.version(),
+        trace = life.repo.trace("__mind__", "activity"),
+        runId = life.run("day-plan", "想具体做什么、几点开始和做多久");
+      let status = "error",
+        reason = "";
+      try {
+        const projects = time.works
+          .projects({ limit: 20 })
+          .filter(
+            (p) =>
+              p.state === "active" &&
+              time.visible(p, task.session_id || "", now),
+          )
+          .slice(0, 6);
+        const answer = await withFallback(
+          life.chat.models,
+          life.chat.fallbackFor(null, profile, trace),
+        ).call(
+          profile,
+          "reflection",
+          replyPrompt(
+            life.mind.nature.current(now),
+            {
+              ...prompts(life.repo),
+              activity: withActivities(
+                '为这件真实待办作一次自己的安排。先把想做的事想具体，再决定几点开始、投入多久。可以马上做，也可以安排晚一些；这不是机械按队列估时。已有主线项目可继续，游戏必须自己选定名称，不能停在“玩一会游戏”。承诺只按原话与语境理解，不能把做不到的承诺改成别的成果算兑现；除了此刻真正能做的事，没有下单、实拍、客户端操作能力。不虚构已执行。只安排本段，可以提前完成或以后续接。输出JSON {"action":"schedule|wait|rest","activity":"write|read|think|game|unknown","title":"具体行动","topic":"游戏名称或空","projectId":"提供的项目ID或null","startAt":"本地YYYY-MM-DD HH:mm","durationMinutes":20,"reason":"自己的选择理由"}。wait表示真正缺少条件，说明reason；rest表示暂时想休息，说明reason。已经明确的承诺不得换目标，私人来源继续属于这件私人事项。',
+              ),
+            },
+            "activity",
+          ),
+          {
+            clock: localClock(now, life.mind.timeZone()),
+            task: {
+              id: task.id,
+              title: task.title,
+              why: task.why,
+              kind: task.kind,
+              activity: task.activity,
+              wait: task.wait_reason,
+              checkpoint: task.checkpoint,
+              earliestAt: task.ready_at,
+              elapsedMs: time.elapsed(task.id, now),
+              timing: time.clock.view(task, now),
+              original: this.context(task, now),
+            },
+            affect: life.mind.affect.state(now),
+            self: life
+              .selfView(now, { room: task.session_id || "" })
+              .slice(0, 6),
+            projects: projects.map((p) => ({
+              id: p.id,
+              kind: p.kind,
+              title: p.title,
+              summary: text(p.summary, 240),
+              topic: p.bible.topic || "",
+            })),
+            available: {
+              read: life.mind.reading.unreadCount() > 0,
+              write: true,
+              think: true,
+              game: !time.search.ready(now),
+              ...pluginAvailable(),
+            },
+            busy: time.tasks
+              .slots(now)
+              .filter((s) => s.id !== task.id)
+              .map(({ startAt, endAt, priority, ongoing }) => ({
+                startAt,
+                endAt,
+                priority,
+                ongoing,
+              })),
+          },
+          trace,
+        );
+        const fresh = time.tasks.get(task.id);
+        if (
+          life.closed ||
+          (time.primary()?.id || null) !== (primary?.id || null) ||
+          fresh?.revision !== revision ||
+          version !== life.mind.nature.version() ||
+          !time.allowed(fresh, life.now())
+        ) {
+          status = "cancelled";
+          return { status };
+        }
+        reason = text(answer?.reason, 240);
+        if (hasCredential(JSON.stringify(answer)))
+          throw Error("安排包含无效内容");
+        if (answer?.action === "wait") {
+          time.tasks.wait(
+            fresh,
+            reason || "还缺少实际执行条件",
+            life.now() + 10 * MINUTE,
+            life.now(),
+          );
+          status = "waiting";
+        } else if (answer?.action === "rest") {
+          time.tasks.control(
+            task.id,
+            {
+              action: "pause",
+              readyAt: life.now() + 10 * MINUTE,
+              reason: reason || "这会儿想先歇着",
+            },
+            life.now(),
+          );
+          status = "resting";
+        } else if (answer?.action === "schedule") {
+          const activity =
+            task.activity === "unknown" ? answer.activity : task.activity;
+          if (!isExecutable(activity)) throw Error("需要把行动内容想具体");
+          const topic = text(answer.topic, 80),
+            title = text(answer.title, 240) || task.title;
+          if (
+            activity === "game" &&
+            !topic &&
+            !gameName(time, { ...task, title })
+          )
+            throw Error("需要自己选定要玩的游戏");
+          const slot = chosenSlot(answer, life, life.now(), now);
+          const project = projects.find(
+            (p) => p.id === answer.projectId && p.kind === activity,
+          );
+          time.tasks.arrange(
+            task.id,
+            {
+              ...slot,
+              startAt: Math.max(slot.startAt, task.ready_at),
+              activity,
+              title:
+                task.kind === "promise" && task.activity !== "unknown"
+                  ? task.title
+                  : title,
+              topic,
+              projectId: project?.id,
+            },
+            life.now(),
+          );
+          status = "planned";
+        } else throw Error("没有得到明确的时间安排");
+        return { status, reason, task: task.id };
+      } catch (error) {
+        reason = text(error.message, 160);
+        trace.error = reason;
+        return { status: "error", reason };
+      } finally {
+        this.working = false;
+        life.chat.finishQuietly(
+          trace,
+          status === "error" ? "error" : "complete",
+        );
+        life.end(runId, status, reason, trace);
+      }
+    });
+  }
+  mark(id, now) {
+    const state = this.state(),
+      attempts = { ...state.attempts, [id]: now };
+    const recent = Object.fromEntries(
+      Object.entries(attempts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 100),
+    );
+    this.life.repo.saveConfig("day-planner", {
+      ...state,
+      attempts: recent,
+      requested: false,
+    });
+  }
+}