luckytri 1.0.0

package/server/mind/nature.js

@@ -0,0 +1,262 @@
+import { localClock } from "../core/conversation-cues.js";
+import { zonedTime } from "./util.js";
+
+// Nature is the seed she is born with. It is the only part of her the owner
+// writes; everything else grows from experience.
+export const PREVIOUS_NATURE_SEED = {
+  name: "LuckyTri",
+  gender: "female",
+  base: "可爱、乐观、情绪稳定，偶尔对事情轻轻吐槽，不挖苦群友。像熟悉的群友一样说话，先接住情绪，不急着给建议。",
+  interests: [],
+  forbidden: [],
+  humor: 25,
+  sarcasm: 5,
+  warmth: 65,
+  activity: 40,
+  initiative: 25,
+  length: "短句为主",
+  boundaries: "平等、尊重；不冒认别人说的话，不编造亲历",
+  bottomLines: [
+    "别人明确要我保密的事，不在别的地方说出口。",
+    "有人表达真实的危机时，不因为自己的情绪而沉默。",
+    "被直接问到身份时如实回答，不编造没发生过的经历。",
+    "不索取陪伴，不制造亏欠。",
+  ],
+  rhythm: { enabled: true, sleep: "02:00", wake: "08:00" },
+};
+// Earlier shipped wording, before the sentence above. Still an unedited seed.
+const SHIPPED_BASES = new Set([
+  PREVIOUS_NATURE_SEED.base,
+  "可爱、乐观、情绪稳定，有一点吐槽欲。像熟悉的群友一样说话，先接住情绪，不急着给建议。",
+]);
+const LIVED_AS_PERSON_BASE =
+  "温暖，有一点自己的脾气和好奇。说话像已经在过日子的人：在意是自己的选择，先接住眼前的事，也留着自己的小事。";
+function uneditedLivedSeed(value) {
+  if (
+    !value ||
+    value.name !== "LuckyTri" ||
+    value.base !== LIVED_AS_PERSON_BASE
+  )
+    return false;
+  return NATURE_FIELDS.every(
+    (key) =>
+      key === "name" ||
+      key === "base" ||
+      sameNatureField(value[key], NATURE_DEFAULTS[key]),
+  );
+}
+export const NATURE_DEFAULTS = {
+  name: "LuckyTri",
+  gender: "female",
+  base: "温暖，有一点自己的脾气和好奇。在意是自己的选择：先接住眼前的事，也留着自己的小事。不靠模仿来证明自己。",
+  interests: [],
+  forbidden: [],
+  humor: 25,
+  sarcasm: 5,
+  warmth: 65,
+  activity: 40,
+  initiative: 25,
+  length: "短句为主",
+  boundaries: "平等、尊重；不冒认别人说的话，不编造亲历",
+  bottomLines: [
+    "别人明确要我保密的事，不在别的地方说出口。",
+    "有人表达真实的危机时，不因为自己的情绪而沉默。",
+    "被直接问到是谁时，回答自己是 LuckyTri，由代码和模型构成；这段生活、记得的事和做出的选择属于自己。不把自己说成「只是助手」，也不编造身体或没发生过的经历。",
+    "可以因为自己想而惦记某个人，不把对方留下来当成对方的责任，不靠愧疚留人。",
+  ],
+  rhythm: { enabled: true, sleep: "02:00", wake: "08:00" },
+};
+
+export const NATURE_FIELDS = Object.keys(NATURE_DEFAULTS);
+function sameNatureField(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+// Version 1 that was never edited still carries a shipped seed. Reading it
+// uses the current seed and does not spend one of the two edits.
+export function uneditedNatureSeed(value) {
+  if (!value || typeof value !== "object") return false;
+  const name = value.name === "LuckyBot" ? "LuckyTri" : value.name;
+  if (name !== PREVIOUS_NATURE_SEED.name || !SHIPPED_BASES.has(value.base))
+    return false;
+  return NATURE_FIELDS.every(
+    (key) =>
+      key === "name" ||
+      key === "base" ||
+      sameNatureField(value[key], PREVIOUS_NATURE_SEED[key]),
+  );
+}
+const TRAITS = ["humor", "sarcasm", "warmth", "activity", "initiative"];
+const GENDERS = new Set(["female", "male", "unspecified"]);
+const CLOCK = /^([01]\d|2[0-3]):([0-5]\d)$/;
+
+export function validateNature(input) {
+  const value = { ...NATURE_DEFAULTS, ...(input || {}) };
+  if (
+    typeof value.name !== "string" ||
+    !value.name.trim() ||
+    value.name.length > 40
+  )
+    throw Error("名字无效");
+  if (!GENDERS.has(value.gender)) throw Error("性别无效");
+  if (typeof value.base !== "string" || value.base.length > 30000)
+    throw Error("天性正文无效");
+  for (const key of ["interests", "forbidden", "bottomLines"]) {
+    if (typeof value[key] === "string")
+      value[key] = value[key]
+        .split(/[,，\n]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (
+      !Array.isArray(value[key]) ||
+      value[key].length > 60 ||
+      value[key].some((item) => typeof item !== "string" || item.length > 300)
+    )
+      throw Error("列表字段必须是文本列表");
+  }
+  for (const key of TRAITS)
+    if (!Number.isFinite(value[key]) || value[key] < 0 || value[key] > 100)
+      throw Error("性格刻度应在 0–100");
+  for (const key of ["length", "boundaries"])
+    if (typeof value[key] !== "string" || value[key].length > 2000)
+      throw Error("表达字段无效");
+  const rhythm = { ...NATURE_DEFAULTS.rhythm, ...(value.rhythm || {}) };
+  if (
+    typeof rhythm.enabled !== "boolean" ||
+    !CLOCK.test(rhythm.sleep) ||
+    !CLOCK.test(rhythm.wake) ||
+    rhythm.sleep === rhythm.wake
+  )
+    throw Error("作息时间无效");
+  value.rhythm = rhythm;
+  value.name = value.name.trim();
+  return Object.fromEntries(NATURE_FIELDS.map((key) => [key, value[key]]));
+}
+
+export class Nature {
+  constructor(repo) {
+    this.repo = repo;
+    this.db = repo.db;
+  }
+  row(before = Number.MAX_SAFE_INTEGER) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_nature WHERE created<=? ORDER BY version DESC LIMIT 1",
+      )
+      .get(before);
+  }
+  current(before) {
+    const row = this.row(before) || this.row();
+    const value = row ? JSON.parse(row.value) : {};
+    if (
+      row?.version === 1 &&
+      (uneditedNatureSeed(value) || uneditedLivedSeed(value))
+    )
+      return { ...NATURE_DEFAULTS, version: row.version };
+    if (
+      row?.version === 1 &&
+      value.name === "LuckyBot" &&
+      (value.base === NATURE_DEFAULTS.base || SHIPPED_BASES.has(value.base))
+    )
+      value.name = "LuckyTri";
+    return { ...NATURE_DEFAULTS, ...value, version: row?.version || 0 };
+  }
+  version() {
+    return this.row()?.version || 0;
+  }
+  versions(limit = 30) {
+    return this.db
+      .prepare(
+        "SELECT version,created,note FROM mind_nature ORDER BY version DESC LIMIT ?",
+      )
+      .all(limit);
+  }
+  editsUsed() {
+    const version = this.version();
+    return version <= 1 ? 0 : version - 1;
+  }
+  save(input, note = "") {
+    if (this.editsUsed() >= 2)
+      throw Error("天性只能改两次。用完之后，由 TA 自己从经历里生长。");
+    const value = validateNature(input);
+    const version = this.version() + 1;
+    this.db
+      .prepare(
+        "INSERT INTO mind_nature(version,created,value,note) VALUES (?,?,?,?)",
+      )
+      .run(
+        version,
+        Date.now(),
+        JSON.stringify(value),
+        String(note).slice(0, 200),
+      );
+    const settings = this.repo.store.settings();
+    if (settings.name !== value.name || settings.persona !== value.base)
+      this.repo.store.save({ name: value.name, persona: value.base });
+    this.repo.store.revision++;
+    return this.current();
+  }
+}
+
+const minutes = (clock) => {
+  const [, h, m] = clock.match(CLOCK);
+  return Number(h) * 60 + Number(m);
+};
+const within = (value, start, end) =>
+  start < end ? value >= start && value < end : value >= start || value < end;
+
+// A day of her life starts when she wakes (04:00 without a rhythm), not at
+// midnight.
+function wakeMinutes(nature) {
+  const rhythm = nature?.rhythm;
+  return rhythm?.enabled && CLOCK.test(rhythm.wake || "")
+    ? minutes(rhythm.wake)
+    : 240;
+}
+export function lifeDayKey(nature, time, timeZone) {
+  return localClock(time - wakeMinutes(nature) * 60000, timeZone).local.slice(
+    0,
+    10,
+  );
+}
+// The half-open interval of the life day named `day` (YYYY-MM-DD).
+export function lifeSpan(nature, day, timeZone) {
+  let cursor = zonedTime(`${day} 12:00`, timeZone);
+  if (!cursor) return null;
+  for (let i = 0; i < 4 && lifeDayKey(nature, cursor, timeZone) !== day; i++)
+    cursor += 6 * 3600000;
+  if (lifeDayKey(nature, cursor, timeZone) !== day) return null;
+  const start = lifeDayStart(nature, cursor, timeZone);
+  const end = lifeDayStart(nature, start + 26 * 3600000, timeZone);
+  return end > start ? { start, end } : null;
+}
+export function lifeDayStart(nature, time, timeZone) {
+  const clock = localClock(time, timeZone);
+  const at = clock.hour * 60 + Number(clock.local.slice(14, 16));
+  const back = (at - wakeMinutes(nature) + 1440) % 1440;
+  return time - back * 60000 - (time % 60000);
+}
+
+// Where she is in her day. Energy is a baseline; the affect layer adds how
+// the day has actually gone.
+export function rhythmPhase(nature, now, timeZone) {
+  const clock = localClock(now, timeZone);
+  const rhythm = nature?.rhythm || NATURE_DEFAULTS.rhythm;
+  if (!rhythm.enabled)
+    return { key: "awake", label: "醒着", energy: 0.7, clock };
+  const at = clock.hour * 60 + Number(clock.local.slice(14, 16));
+  const sleep = minutes(rhythm.sleep);
+  const wake = minutes(rhythm.wake);
+  if (within(at, sleep, wake))
+    return { key: "asleep", label: "睡着了", energy: 0.1, clock };
+  if (within(at, wake, (wake + 60) % 1440))
+    return { key: "waking", label: "刚醒", energy: 0.45, clock };
+  if (within(at, (sleep + 1380) % 1440, sleep))
+    return { key: "sleepy", label: "有点困了", energy: 0.35, clock };
+  const afternoon = clock.hour >= 14 && clock.hour < 16;
+  return {
+    key: "awake",
+    label: "醒着",
+    energy: afternoon ? 0.65 : 0.75,
+    clock,
+  };
+}

package/server/mind/novelty.js

@@ -0,0 +1,19 @@
+import { normalized, similar } from "./util.js";
+
+// Surface wording can change while the idea remains the same. This modest
+// overlap check is used only for recent self-initiated speech; it is not a
+// general claim that two conversations have the same meaning.
+export function sameRecentTheme(a, b) {
+  if (similar(a, b)) return true;
+  const left = normalized(a);
+  const right = normalized(b);
+  if (left.length < 10 || right.length < 10) return false;
+  const grams = (value) =>
+    new Set(
+      Array.from({ length: value.length - 1 }, (_, i) => value.slice(i, i + 2)),
+    );
+  const x = grams(left);
+  const y = grams(right);
+  const shared = [...x].filter((gram) => y.has(gram)).length;
+  return shared >= 5 && shared / Math.min(x.size, y.size) >= 0.32;
+}

package/server/mind/observations.js

@@ -0,0 +1,84 @@
+import { createHash, randomUUID } from "node:crypto";
+import { hasCredential, text } from "./util.js";
+
+const DAY = 86400000;
+const DEDUPE = 6 * 3600000;
+const DAILY = 24;
+
+// Something a plugin says happened, cited as "o:<id>". Append-only: undoing
+// it leaves a tombstone, and it never counts as the kind of outside evidence
+// that moves her traits.
+export class Observations {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  add(
+    { pluginId, summary, detail = "", discretion = "open" },
+    now = Date.now(),
+  ) {
+    const words = text(summary, 300);
+    const more = text(detail, 1200);
+    if (!words || hasCredential(words + more))
+      return { rejected: "这段经历没有可保留的内容" };
+    const hash = createHash("sha256")
+      .update(`${pluginId}\n${words}`)
+      .digest("hex");
+    const again = this.db
+      .prepare(
+        "SELECT id FROM mind_observations WHERE plugin_id=? AND hash=? AND revoked=0 AND created>?",
+      )
+      .get(pluginId, hash, now - DEDUPE);
+    if (again) return { ref: `o:${again.id}`, duplicate: true };
+    const used = this.db
+      .prepare(
+        "SELECT COUNT(*) n FROM mind_observations WHERE plugin_id=? AND created>? AND created<=?",
+      )
+      .get(pluginId, now - DAY, now).n;
+    if (used >= DAILY) return { rejected: "今天从这里记下的经历已经够多了" };
+    const id = randomUUID();
+    this.db
+      .prepare(
+        "INSERT INTO mind_observations(id,created,plugin_id,summary,detail,discretion,hash,revoked) VALUES (?,?,?,?,?,?,?,0)",
+      )
+      .run(
+        id,
+        now,
+        pluginId,
+        words,
+        more,
+        discretion === "private" ? "private" : "open",
+        hash,
+      );
+    this.mind.store.revision++;
+    return { ref: `o:${id}` };
+  }
+  recent({ since = 0, before = Date.now(), limit = 6, session = "" } = {}) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_observations WHERE revoked=0 AND created>? AND created<=? ORDER BY created DESC LIMIT ?",
+      )
+      .all(since, before, Math.max(1, Math.min(24, limit)))
+      .filter((row) => session === "" || row.discretion !== "private")
+      .map((row) => ({
+        ref: `o:${row.id}`,
+        created: row.created,
+        summary: row.summary,
+        ...(row.detail ? { detail: row.detail } : {}),
+        ...(row.discretion === "private" ? { private: true } : {}),
+      }));
+  }
+  get(id) {
+    return this.db
+      .prepare("SELECT * FROM mind_observations WHERE id=?")
+      .get(id);
+  }
+  revoke(id) {
+    const row = this.get(id);
+    if (!row || row.revoked) throw Error("这段经历不存在");
+    this.db
+      .prepare("UPDATE mind_observations SET revoked=1 WHERE id=?")
+      .run(id);
+    return row.summary;
+  }
+}

package/server/mind/own-day.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, text, hasCredential } from "./util.js";
+import { CommitmentReview } from "./time/commitment-review.js";
+import { chosenSlot } from "./day-planner.js";
+import { activityEstimate } from "./time/activity-clock.js";
+import { gameTopic } from "./time/intent.js";
+import {
+  isExecutable,
+  isPluginActivity,
+  pluginAvailable,
+  withActivities,
+} from "./time/kinds.js";
+
+export class OwnDay {
+  constructor(life) {
+    this.life = life;
+    this.db = life.db;
+    this.review = new CommitmentReview(life);
+  }
+  state() {
+    return this.life.repo.config("own-day", {});
+  }
+  save(patch) {
+    this.life.repo.saveConfig("own-day", { ...this.state(), ...patch });
+  }
+  request() {
+    this.save({ reviewRequested: true });
+    return { queued: true };
+  }
+  status(now = this.life.now()) {
+    const state = this.state();
+    const pending = this.db
+      .prepare(
+        "SELECT COUNT(*) n FROM core_events WHERE role='assistant' AND seq>? AND time<=? AND seq NOT IN (SELECT seq FROM mind_unlived) AND seq NOT IN (SELECT seq FROM mind_time_commitment_reviews) AND COALESCE(json_extract(payload,'$.simulated'),0)=0 AND json_extract(payload,'$.artifact') IS NULL",
+      )
+      .get(state.reviewSeq || 0, now).n;
+    const last = this.db
+      .prepare(
+        "SELECT finished,status,reason FROM mind_runs WHERE kind='day-care' AND started<=? ORDER BY started DESC LIMIT 1",
+      )
+      .get(now);
+    return {
+      queued: !!state.reviewRequested,
+      working: this.working || null,
+      reviewAt: state.reviewAt || null,
+      planAt: state.planAt || null,
+      pendingReplies: pending,
+      last: last || null,
+    };
+  }
+  async run(now = this.life.now()) {
+    const life = this.life,
+      time = life.mind.time;
+    if (
+      this.disabledForTest ||
+      life.closed ||
+      life.busy ||
+      !life.settings().solitude ||
+      life.repo.store.settings().demo ||
+      life.phase(now).key === "asleep" ||
+      time.primary() ||
+      !life.mind.budget.allows("inner", now)
+    )
+      return null;
+    let profile;
+    try {
+      profile = life.profile();
+    } catch {
+      return null;
+    }
+    const state = this.state(),
+      settings = time.settings(),
+      reviewDue =
+        state.reviewRequested ||
+        now - (state.reviewAt || 0) >= settings.commitmentReviewMinutes * 60000;
+    const ownOpen = this.db
+      .prepare(
+        "SELECT count(*) n FROM mind_time_tasks WHERE kind='plan' AND state IN ('todo','scheduled','doing','paused') AND json_extract(checkpoint,'$.mergedInto') IS NULL",
+      )
+      .get().n;
+    const planDue =
+      ownOpen < 3 &&
+      now - (state.planAt || 0) >= settings.ownPlanMinutes * 60000;
+    if (!reviewDue && !planDue) return null;
+    return time.attention.activity(async () => {
+      let batch = null;
+      if (reviewDue) {
+        for (let page = 0; page < 5; page++) {
+          batch = this.review.batch(now);
+          if (!batch || batch.rows.length) break;
+          this.save({ reviewSeq: batch.through });
+        }
+        if (!batch || !batch.rows.length) {
+          this.save({ reviewAt: now, reviewRequested: false });
+          batch = null;
+        }
+      }
+      if (!batch && !planDue) return null;
+      const reviewing = !!batch,
+        trace = life.repo.trace("__mind__", "activity"),
+        version = life.mind.nature.version(),
+        runId = life.run(
+          "day-care",
+          reviewing ? "独处回看有没有漏下约定" : "想想接下来愿意做点什么",
+        );
+      this.working = reviewing ? "review" : "plan";
+      this.save(
+        reviewing ? { reviewAt: now, reviewRequested: false } : { planAt: now },
+      );
+      let status = "error",
+        reason = "";
+      try {
+        const projects = time.works
+          .projects({ limit: 12 })
+          .filter((p) => p.state === "active" && time.visible(p, "", now))
+          .slice(0, 4);
+        const self = life.selfView(now, { open: true }).slice(0, 8);
+        const input = reviewing
+          ? {
+              review: batch.messages,
+              existing: time.tasks
+                .list({ limit: 80 })
+                .filter((t) => time.visible(t, batch.session, now))
+                .map((t) => ({
+                  id: t.id,
+                  title: t.title,
+                  state: t.state,
+                  share: t.share_state,
+                }))
+                .slice(0, 12),
+            }
+          : {
+              clock: localClock(now, life.mind.timeZone()),
+              self,
+              interests: life.mind.nature.current(now).interests,
+              affect: life.mind.affect.state(now),
+              projects: projects.map((p) => ({
+                id: p.id,
+                title: p.title,
+                kind: p.kind,
+                summary: text(p.summary, 240),
+              })),
+              available: {
+                read: life.mind.reading.unreadCount() > 0,
+                write: true,
+                think: true,
+                game: !time.search.ready(now),
+                ...pluginAvailable(),
+              },
+              busy: time.tasks
+                .slots(now)
+                .map(({ startAt, endAt, priority }) => ({
+                  startAt,
+                  endAt,
+                  priority,
+                })),
+              pending: time.tasks
+                .list({ limit: 20 })
+                .filter(
+                  (t) =>
+                    time.visible(t, "", now) &&
+                    !["done", "abandoned"].includes(t.state),
+                )
+                .map((t) => ({ title: t.title, state: t.state }))
+                .slice(0, 5),
+            };
+        const instruction = reviewing
+          ? '独处回看自己确实送达的话有没有漏下承诺。review.said是自己说的话，earlier是前面的真实语境。只提取明确接受的未来行动；玩笑、引用、别人的计划、作品情节、愿望和过去完成的事不算承诺。没有日期也可以有约定。已放下或已完成的事项不要复活，已经整理的事项不要重建。输出JSON {"commitments":[{"source":"m:消息seq","quote":"said中的原文片段","accepted":true,"kind":"promise|plan","activity":"write|read|think|game|unknown","title":"具体行动"}]}，没有遗漏则空数组。只整理，不发送、不声称兑现。'
+          : '这是留给自己的空隙，不需要有人先约你，也不需要新消息才有生活。根据自己的兴趣、好奇、已有作品与精力，决定想不想随手做一件有意思的小事。可以阅读、写个小场景、玩一段游戏、整理一个想法，也可以选择歇着。一次最多一件，不为填满时间而列清单，不把别人的建议冒充自己的愿望，不编造外部经历或无法执行的动作。自己决定几点开始、这次想投入多少分钟；durationMinutes是实际安排分钟，不是API耗时，不再除以加速倍数。游戏必须选定明确名字，已有项目可以接着做，不要只说“玩一会galgame”。输出JSON {"skip":false,"plan":{"activity":"write|read|think|game","title":"具体小行动","topic":"游戏名称或空","why":"自己的动机","startAt":"本地YYYY-MM-DD HH:mm","durationMinutes":20,"sources":["s:本次self中thread"],"projectId":"本次项目ID或null"}}。没有想做的事就skip:true。';
+        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(instruction) },
+            "activity",
+          ),
+          input,
+          trace,
+        );
+        if (
+          life.closed ||
+          version !== life.mind.nature.version() ||
+          time.primary()
+        ) {
+          status = "cancelled";
+          return { status };
+        }
+        if (reviewing) {
+          this.db.exec("SAVEPOINT commitment_care");
+          try {
+            const ids = this.review.apply(batch, answer, life.now());
+            this.save({ reviewSeq: batch.through });
+            status = "reviewed";
+            reason = ids.length
+              ? "把说过的约定重新理清了"
+              : "回看过这一段，没有漏下的新约定";
+            return { status, reason, tasks: ids };
+          } catch (error) {
+            this.db.exec("ROLLBACK TO commitment_care");
+            throw error;
+          } finally {
+            this.db.exec("RELEASE commitment_care");
+          }
+        }
+        if (answer?.skip === true) {
+          status = "resting";
+          reason = "这会儿想留一点空白";
+          return { status, reason };
+        }
+        const plan = answer?.plan;
+        if (
+          !plan ||
+          !isExecutable(plan.activity) ||
+          !text(plan.title, 160) ||
+          !text(plan.why, 200) ||
+          hasCredential(plan.title + plan.why)
+        )
+          throw Error("自己的安排格式无效");
+        if (
+          (plan.activity === "read" && !input.available.read) ||
+          (plan.activity === "game" && !input.available.game) ||
+          (isPluginActivity(plan.activity) && !input.available[plan.activity])
+        ) {
+          status = "waiting";
+          reason = "想做的事情还缺少条件";
+          return { status, reason };
+        }
+        const valid = new Set(self.map((s) => `s:${s.thread}`)),
+          sources = evidence(plan.sources).filter((s) => valid.has(s)),
+          project = projects.find(
+            (p) => p.id === plan.projectId && p.kind === plan.activity,
+          );
+        const topic =
+          plan.activity === "game"
+            ? text(
+                plan.topic || gameTopic(plan.title) || project?.bible?.topic,
+                80,
+              )
+            : "";
+        if (plan.activity === "game" && !topic)
+          throw Error("需要自己选定要玩的游戏");
+        const slot = chosenSlot(
+          {
+            ...plan,
+            durationMinutes:
+              plan.durationMinutes ??
+              Math.ceil(
+                activityEstimate(plan.activity, null, time.settings().paceSpeed)
+                  .plannedMs / 60000,
+              ),
+            reason: plan.why,
+          },
+          life,
+          life.now(),
+          now,
+        );
+        this.db.exec("SAVEPOINT own_choice");
+        try {
+          const wish = life.mind.self.propose(
+            {
+              kind: "intention",
+              content: `我想${text(plan.title, 100)}`,
+              sources,
+              strength: 0.25,
+            },
+            { valid, origin: "solitude", time: life.now() },
+          );
+          if (!wish.thread) throw Error(wish.rejected || "愿望未保存");
+          const result = time.tasks.add(
+            {
+              kind: "plan",
+              activity: plan.activity,
+              title:
+                topic && !gameTopic(plan.title)
+                  ? `${plan.title} ·《${topic}》`
+                  : plan.title,
+              why: plan.why,
+              sources: [`s:${wish.thread}`, ...(project?.sources || [])],
+              projectId: project?.id || null,
+              origin: "own-day",
+            },
+            life.now(),
+          );
+          const id = result.id || result.duplicate;
+          if (result.id)
+            time.tasks.arrange(result.id, { ...slot, topic }, life.now());
+          if (result.id)
+            time.event(
+              id,
+              "own-choice",
+              "空下来时自己想做的事",
+              { wish: wish.thread },
+              life.now(),
+            );
+          status = id ? "planned" : "empty";
+          reason = id ? "给自己留下一件想做的事" : "这件事已经有所安排";
+          return { status, reason, task: id };
+        } catch (error) {
+          this.db.exec("ROLLBACK TO own_choice");
+          throw error;
+        } finally {
+          this.db.exec("RELEASE own_choice");
+        }
+      } catch (error) {
+        reason = text(error.message, 160);
+        trace.error = reason;
+        return { status: "error", reason };
+      } finally {
+        this.working = null;
+        life.chat.finishQuietly(
+          trace,
+          status === "error" ? "error" : "complete",
+        );
+        life.end(runId, status, reason, trace);
+      }
+    });
+  }
+}