luckytri 1.0.0

package/server/mind/thoughts.js

@@ -0,0 +1,274 @@
+import { randomUUID } from "node:crypto";
+import { evidenceRoots } from "./evidence.js";
+import {
+  THOUGHT_FADED,
+  anyTouches,
+  cueList,
+  thoughtSalience,
+} from "./salience.js";
+import { HOUR, clamp, evidence, parse, text } from "./util.js";
+
+export const THOUGHT_KINDS = {
+  reflection: "后来想到",
+  revision: "重新理解",
+  unfinished: "仍放在心上",
+  reconnection: "久别想起",
+  expression: "自己的念头",
+};
+
+function row(value) {
+  return value
+    ? {
+        ...value,
+        sessions: parse(value.sessions, []),
+        sources: parse(value.sources, []),
+        outreach_draft: parse(value.outreach_draft, []),
+      }
+    : null;
+}
+
+// Her journal between conversations. A later understanding is a new entry
+// pointing at the old one; the old words stay as they were.
+export class Thoughts {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  add({
+    kind,
+    content,
+    sessions = [],
+    sources = [],
+    parentId = null,
+    importance = 0.5,
+    revisitHours = 0,
+    outreach = "",
+    outreachSession = null,
+    outreachAfterHours,
+    outreachReason = "",
+    runId = null,
+    time = Date.now(),
+  }) {
+    const id = randomUUID();
+    const hours = Number(revisitHours);
+    this.db
+      .prepare(
+        "INSERT INTO mind_thoughts(id,created,kind,content,sessions,sources,parent_id,importance,revisit_at,status,hidden,outreach,outreach_session,outreach_status,run_id,outreach_at,outreach_reason) VALUES (?,?,?,?,?,?,?,?,?,'open',0,?,?,?,?,?,?)",
+      )
+      .run(
+        id,
+        time,
+        THOUGHT_KINDS[kind] ? kind : "reflection",
+        text(content, 600),
+        JSON.stringify([...new Set(sessions)].slice(0, 12)),
+        JSON.stringify(evidence(sources)),
+        parentId || null,
+        clamp(importance),
+        Number.isFinite(hours) && hours > 0
+          ? time + Math.min(8760, Math.max(1, hours)) * HOUR
+          : null,
+        text(outreach, 120),
+        outreach ? outreachSession : null,
+        outreach ? "planned" : "none",
+        runId,
+        outreach
+          ? time +
+              Math.min(
+                8760,
+                Math.max(0, Number(outreachAfterHours ?? revisitHours) || 0),
+              ) *
+                HOUR
+          : null,
+        text(outreachReason, 300),
+      );
+    return id;
+  }
+  get(id) {
+    return row(
+      this.db.prepare("SELECT * FROM mind_thoughts WHERE id=?").get(id),
+    );
+  }
+  list({
+    before = Number.MAX_SAFE_INTEGER,
+    session = "",
+    q = "",
+    limit = 30,
+    hidden = true,
+  } = {}) {
+    return this.db
+      .prepare(
+        `SELECT * FROM mind_thoughts WHERE created<?${hidden ? "" : " AND hidden=0"}${session ? " AND sessions LIKE ?" : ""}${q ? " AND content LIKE ?" : ""} ORDER BY created DESC LIMIT ?`,
+      )
+      .all(
+        before,
+        ...(session ? [`%${JSON.stringify(session).slice(1, -1)}%`] : []),
+        ...(q ? [`%${q}%`] : []),
+        limit,
+      )
+      .map(row);
+  }
+  // Still on her mind at `now`, ranked by how present each one is; a thought
+  // let go of later still counts as open when looking back. A later note
+  // that only repeats sources already used does not start this clock over.
+  weighed({ now = Date.now(), session = "" } = {}) {
+    const lived = this.mind.days.lived(now);
+    const notes = this.db
+      .prepare(
+        "SELECT * FROM mind_thoughts WHERE hidden=0 AND created<=? AND (status='open' OR resolved_at>?) ORDER BY created DESC LIMIT 400",
+      )
+      .all(now, now)
+      .map(row)
+      .filter((t) => !session || t.sessions.includes(session));
+    const clock = sourceClock(notes, (sources) =>
+      evidenceRoots(this.db, sources, now),
+    );
+    return notes
+      .map((t) => {
+        const earned = clock.get(t.id) ?? t.created;
+        // A revisit brings back the note that actually lived the experience.
+        // Rewriting it later and setting another time does not.
+        const seen = earned < t.created ? { ...t, revisit_at: null } : t;
+        return {
+          ...t,
+          salience: thoughtSalience({ ...seen, created: earned }, lived, now),
+        };
+      })
+      .sort((a, b) => b.salience - a.salience || b.created - a.created);
+  }
+  open({ now = Date.now(), limit = 12, session = "" } = {}) {
+    return this.weighed({ now, session })
+      .filter((t) => t.salience >= THOUGHT_FADED)
+      .slice(0, limit);
+  }
+  // The studio card shows the newest note still in view. Salience still
+  // decides which thoughts a conversation carries.
+  latest(now = Date.now()) {
+    return (
+      this.open({ now, limit: 40 }).sort((a, b) => b.created - a.created)[0] ||
+      null
+    );
+  }
+  // Faded thoughts from this place that the conversation brings back.
+  reminded({ now = Date.now(), cue, cues, session = "", limit = 1 } = {}) {
+    const sets = cueList(cue, cues);
+    if (!sets.length) return [];
+    return this.weighed({ now, session })
+      .filter((t) => t.salience < THOUGHT_FADED && anyTouches(t.content, sets))
+      .slice(0, limit);
+  }
+  resolve(id, resolution = "", time = Date.now()) {
+    return (
+      this.db
+        .prepare(
+          "UPDATE mind_thoughts SET status='resolved',resolved_at=?,resolution=? WHERE id=? AND status='open'",
+        )
+        .run(time, text(resolution, 120), id).changes > 0
+    );
+  }
+  update(id, { status, hidden }) {
+    const current = this.get(id);
+    if (!current) throw Error("手记不存在");
+    if (status !== undefined && !["open", "resolved"].includes(status))
+      throw Error("状态无效");
+    if (hidden !== undefined && typeof hidden !== "boolean")
+      throw Error("开关无效");
+    const next = status ?? current.status;
+    const resolved =
+      next === current.status
+        ? [current.resolved_at ?? null, current.resolution ?? ""]
+        : next === "resolved"
+          ? [Date.now(), "在工作台里放下"]
+          : [null, ""];
+    this.db
+      .prepare(
+        "UPDATE mind_thoughts SET status=?,hidden=?,resolved_at=?,resolution=? WHERE id=?",
+      )
+      .run(
+        next,
+        hidden === undefined ? current.hidden : +hidden,
+        ...resolved,
+        id,
+      );
+  }
+  remove(id) {
+    if (
+      this.db.prepare("SELECT 1 FROM mind_thoughts WHERE parent_id=?").get(id)
+    )
+      throw Error("这条手记有后续修正，请隐藏以保留轨迹");
+    this.db.prepare("DELETE FROM mind_thoughts WHERE id=?").run(id);
+  }
+  setOutreach(id, status, reason = "") {
+    this.db
+      .prepare(
+        "UPDATE mind_thoughts SET outreach_status=?,outreach_wait_reason=?,outreach_retry_at=NULL WHERE id=?",
+      )
+      .run(status, text(reason, 300), id);
+  }
+  planOutreach(id, { session, words, reason, time }) {
+    const current = this.get(id);
+    if (!current || current.outreach_status !== "none") return false;
+    const draft = words
+      .filter((s) => typeof s === "string" && s.trim())
+      .slice(0, 3)
+      .map((s) => text(s, 180));
+    if (!session || !draft.length) return false;
+    this.db
+      .prepare(
+        "UPDATE mind_thoughts SET sessions=?,outreach=?,outreach_session=?,outreach_status='planned',outreach_at=?,outreach_reason=?,outreach_draft=? WHERE id=? AND outreach_status='none'",
+      )
+      .run(
+        // An independent thought is not owned by its first audience. Keep its
+        // origin scope; outreach_session records where she chose to share it.
+        JSON.stringify(
+          current.kind === "expression"
+            ? current.sessions
+            : [...new Set([...current.sessions, session])],
+        ),
+        draft.join("\n"),
+        session,
+        time,
+        text(reason, 300),
+        JSON.stringify(draft),
+        id,
+      );
+    return true;
+  }
+  deferOutreach(id, reason, retryAt) {
+    this.db
+      .prepare(
+        "UPDATE mind_thoughts SET outreach_status='planned',outreach_wait_reason=?,outreach_retry_at=? WHERE id=?",
+      )
+      .run(text(reason, 300), retryAt, id);
+  }
+  dueOutreach(now = Date.now()) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_thoughts WHERE outreach_status='planned' AND hidden=0 AND status='open' AND outreach!='' AND COALESCE(outreach_at,revisit_at,created)<=? AND COALESCE(outreach_retry_at,0)<=? ORDER BY importance DESC, created LIMIT 5",
+      )
+      .all(now, now)
+      .map(row);
+  }
+}
+
+// The first time a source was lived. A later note that only repeats those
+// sources keeps that time, so rewriting it does not make it newly present.
+function sourceClock(notes, roots) {
+  const earned = new Map();
+  const clock = new Map();
+  for (const note of [...notes].sort((a, b) => a.created - b.created)) {
+    const resolved = roots(note.sources);
+    const sources = resolved.length ? resolved : [`t:${note.id}`];
+    const fresh = sources.some((source) => !earned.has(source));
+    if (fresh) {
+      clock.set(note.id, note.created);
+      for (const source of sources)
+        if (!earned.has(source)) earned.set(source, note.created);
+    } else {
+      clock.set(
+        note.id,
+        Math.min(...sources.map((source) => earned.get(source))),
+      );
+    }
+  }
+  return clock;
+}

package/server/mind/time/activity-clock.js

@@ -0,0 +1,196 @@
+import { text } from "../util.js";
+import { activityMinutes } from "./kinds.js";
+const MINUTE = 60000;
+export function activityEstimate(activity, hint, speed = 1.25) {
+  const fallback = activityMinutes(activity),
+    proposed = Number(hint?.minutes);
+  const referenceMinutes =
+    Number.isFinite(proposed) && proposed >= 5 && proposed <= 240
+      ? proposed
+      : fallback[0];
+  const pace =
+    Number.isFinite(speed) && speed >= 1 && speed <= 2 ? speed : 1.25;
+  return {
+    referenceMinutes,
+    plannedMs: Math.ceil((referenceMinutes * MINUTE) / pace),
+    speed: pace,
+    basis: text(hint?.basis, 240) || fallback[1],
+    scope: "本段",
+    chapterMinutes:
+      Number.isFinite(hint?.chapterMinutes) &&
+      hint.chapterMinutes >= referenceMinutes &&
+      hint.chapterMinutes <= 6000
+        ? hint.chapterMinutes
+        : null,
+  };
+}
+export class ActivityClock {
+  constructor(time) {
+    this.time = time;
+    this.db = time.db;
+  }
+  committed(id) {
+    return this.db
+      .prepare(
+        "SELECT COALESCE(SUM(engaged_ms),0) n FROM mind_time_spans WHERE task_id=?",
+      )
+      .get(id).n;
+  }
+  record(span, ms) {
+    if (ms > 0)
+      this.db
+        .prepare(
+          "INSERT OR IGNORE INTO mind_time_activity_ticks(span_id,started,ended) VALUES(?,?,?)",
+        )
+        .run(span.id, span.updated, span.updated + ms);
+  }
+  today(spanId, start, now) {
+    return this.db
+      .prepare(
+        "SELECT COALESCE(SUM(MAX(0,MIN(ended,?)-MAX(started,?))),0) n FROM mind_time_activity_ticks WHERE span_id=? AND ended>? AND started<?",
+      )
+      .get(now, start, spanId, start, now).n;
+  }
+  credit(task, delta) {
+    const clock = task.checkpoint?.activityClock;
+    if (
+      !clock ||
+      clock.phase !== "engaged" ||
+      task.lease ||
+      task.state !== "doing"
+    )
+      return 0;
+    return Math.max(
+      0,
+      Math.min(
+        delta,
+        Math.round(
+          clock.plannedMs - (this.committed(task.id) - clock.baselineMs),
+        ),
+      ),
+    );
+  }
+  elapsed(task, now = this.time.now()) {
+    const total = this.committed(task.id),
+      span = this.db
+        .prepare(
+          "SELECT updated FROM mind_time_spans WHERE task_id=? AND ended IS NULL",
+        )
+        .get(task.id);
+    return (
+      total +
+      (span
+        ? this.credit(task, Math.max(0, Math.min(MINUTE, now - span.updated)))
+        : 0)
+    );
+  }
+  plan(task, hint, now) {
+    const estimate = activityEstimate(
+      task.activity,
+      hint,
+      this.time.settings().paceSpeed,
+    );
+    if (task.checkpoint.schedule?.chosenAt) {
+      const used =
+        this.db
+          .prepare(
+            "SELECT engaged_ms FROM mind_time_spans WHERE task_id=? AND ended IS NULL",
+          )
+          .get(task.id)?.engaged_ms || 0;
+      estimate.plannedMs = Math.min(
+        estimate.plannedMs,
+        Math.max(MINUTE, this.time.focusMs(task) - used),
+      );
+    }
+    return {
+      version: 1,
+      phase: "engaged",
+      ...estimate,
+      baselineMs: this.committed(task.id),
+      started: now,
+    };
+  }
+  view(task, now = this.time.now()) {
+    const clock = task.checkpoint?.activityClock;
+    if (!clock)
+      return {
+        phase:
+          !this.time.fixtureImmediate &&
+          this.time.operationElapsed(task.id, now) > 0
+            ? "legacy"
+            : "unstarted",
+        elapsedMs: this.time.fixtureImmediate
+          ? this.time.operationElapsed(task.id, now)
+          : null,
+        plannedMs: null,
+      };
+    const elapsedMs = this.elapsed(task, now),
+      stepMs = Math.max(0, elapsedMs - clock.baselineMs);
+    return {
+      phase: clock.phase,
+      elapsedMs,
+      stepMs,
+      plannedMs: clock.plannedMs,
+      remainingMs: Math.max(0, Math.round(clock.plannedMs - stepMs)),
+      progress: clock.plannedMs > 0 ? Math.min(1, stepMs / clock.plannedMs) : 0,
+      referenceMinutes: clock.referenceMinutes,
+      speed: clock.speed,
+      basis: clock.basis,
+      chapterMinutes: clock.chapterMinutes,
+    };
+  }
+  remaining(task, now) {
+    return this.view(task, now).remainingMs || 0;
+  }
+  release(task, checkpoint, now) {
+    const slot = checkpoint.schedule,
+      clock = checkpoint.activityClock;
+    if (
+      task.activity !== "game" &&
+      slot?.chosenAt &&
+      clock.phase === "engaged"
+    ) {
+      const base = Math.max(clock.baselineMs, slot.baselineMs || 0);
+      const remainingAtStart = Math.max(
+        0,
+        clock.plannedMs - (base - clock.baselineMs),
+      );
+      const quota = Math.max(
+        MINUTE,
+        this.time.focusMs(task) - Math.max(0, base - (slot.baselineMs || 0)),
+      );
+      if (remainingAtStart > quota)
+        checkpoint = {
+          ...checkpoint,
+          activityClock: {
+            ...clock,
+            originalEstimateMs: clock.originalEstimateMs || clock.plannedMs,
+            baselineMs: base,
+            plannedMs: quota,
+          },
+        };
+    }
+    this.db
+      .prepare(
+        "UPDATE mind_time_spans SET updated=? WHERE task_id=? AND ended IS NULL",
+      )
+      .run(now, task.id);
+    const rest = this.time.focusMs(task),
+      remaining = Math.max(
+        0,
+        Math.round(
+          checkpoint.activityClock.plannedMs -
+            (this.committed(task.id) - checkpoint.activityClock.baselineMs),
+        ),
+      );
+    this.db
+      .prepare(
+        "UPDATE mind_time_tasks SET checkpoint=?,next_step=?,lease=NULL,lease_at=NULL,revision=revision+1 WHERE id=?",
+      )
+      .run(
+        JSON.stringify(checkpoint),
+        now + Math.min(rest, remaining),
+        task.id,
+      );
+  }
+}

package/server/mind/time/agenda.js

@@ -0,0 +1,242 @@
+import { dayKey, zonedTime, parse } from "../util.js";
+import { activityPresentation } from "./presentation.js";
+import { executionBlock } from "./availability.js";
+
+// A view of saved choices and actual spans. Reading it never makes a plan.
+export class Agenda {
+  constructor(time) {
+    this.time = time;
+    this.db = time.db;
+  }
+  blocked(task, now) {
+    if (task.state === "paused" && task.next_step >= Number.MAX_SAFE_INTEGER)
+      return task.wait_reason || "自己选择暂停，等待重新安排";
+    return executionBlock(this.time, task, now);
+  }
+  view(now = this.time.now()) {
+    const time = this.time,
+      zone = time.mind.timeZone(),
+      date = dayKey(now, zone);
+    const nextDate = new Date(Date.parse(date + "T12:00:00Z") + 86400000)
+      .toISOString()
+      .slice(0, 10);
+    const start = zonedTime(date, zone),
+      end = zonedTime(nextDate, zone),
+      today = time.today(now),
+      primary = time.primary();
+    const actual = today.spans
+      .map((s) => {
+        const rename = this.db
+          .prepare(
+            "SELECT data FROM mind_time_events WHERE task_id=? AND kind='self-scheduled' AND created>=? ORDER BY created,id LIMIT 1",
+          )
+          .get(s.task_id, s.started);
+        const title = parse(rename?.data, {}).previousTitle || s.title;
+        return {
+          id: s.id,
+          taskId: s.task_id,
+          title,
+          activity: s.activity,
+          start: Math.max(start, s.started),
+          end: Math.min(now, s.ended ?? s.updated),
+          engagedMs: s.clocked || time.fixtureImmediate ? s.todayMs : null,
+          ongoing: !s.ended && primary?.id === s.task_id,
+          kind: "actual",
+          label:
+            !s.ended && primary?.id === s.task_id
+              ? primary.checkpoint.activityClock?.phase === "preparing"
+                ? "准备中"
+                : "正在做"
+              : s.clocked && !s.todayMs
+                ? "准备时段"
+                : "已发生",
+        };
+      })
+      .filter((s) => s.end > s.start);
+    const planned = [],
+      waiting = [],
+      unarranged = [],
+      paused = [];
+    const rows = this.db
+      .prepare(
+        "SELECT id FROM mind_time_tasks WHERE created<=? AND state IN ('todo','scheduled','doing','paused','waiting') AND json_extract(checkpoint,'$.mergedInto') IS NULL ORDER BY priority DESC,created LIMIT 100",
+      )
+      .all(now);
+    for (const row of rows) {
+      const task = time.tasks.get(row.id),
+        view = activityPresentation(task),
+        slot = task.checkpoint.schedule;
+      const why = this.blocked(task, now);
+      if (task.state === "paused") {
+        if (paused.length < 12)
+          paused.push({
+            id: task.id,
+            title: view.title,
+            reason: task.wait_reason || "暂时停下来，进度已保存",
+          });
+        continue;
+      }
+      if (why || task.state === "waiting") {
+        if (waiting.length < 12)
+          waiting.push({
+            id: task.id,
+            title: view.title,
+            reason: why || task.wait_reason,
+            retryAt:
+              task.next_step < Number.MAX_SAFE_INTEGER ? task.next_step : null,
+          });
+        continue;
+      }
+      if (
+        !slot?.chosenAt ||
+        task.checkpoint.reschedule ||
+        (slot.endedAt <= now && task.state !== "doing")
+      ) {
+        if (unarranged.length < 12)
+          unarranged.push({
+            id: task.id,
+            title: view.title,
+            reason: slot?.chosenAt
+              ? "原安排已过去，等她重新选时间"
+              : "事情已经记下，等她选择几点做、做多久",
+          });
+        continue;
+      }
+      if (slot.proposedAt >= end || slot.endedAt <= start) {
+        if (unarranged.length < 12)
+          unarranged.push({
+            id: task.id,
+            title: view.title,
+            reason: "安排在今天之外",
+            startAt: slot.proposedAt,
+          });
+        continue;
+      }
+      planned.push({
+        id: "slot:" + task.id,
+        kind: "activity",
+        taskId: task.id,
+        title: view.title,
+        activity: task.activity,
+        kindOfTask: task.kind,
+        priority: task.priority,
+        start: Math.max(start, slot.proposedAt),
+        end: Math.min(end, slot.endedAt),
+        chosenStart: slot.proposedAt,
+        chosenEnd: slot.endedAt,
+        durationMinutes: slot.durationMinutes,
+        why: slot.reason || view.why,
+        label:
+          task.state === "doing"
+            ? "正在执行这份安排"
+            : slot.chosenBy === "admin"
+              ? "管理台安排"
+              : "她选定的安排",
+        estimated: false,
+        scope: "这次投入",
+        state: task.state,
+      });
+    }
+    const rhythm = time.mind.nature.current(now).rhythm;
+    if (rhythm?.enabled) {
+      const bed = zonedTime(date + " " + rhythm.sleep, zone),
+        wake = zonedTime(date + " " + rhythm.wake, zone);
+      for (const [a, b] of bed < wake
+        ? [[bed, wake]]
+        : [
+            [start, wake],
+            [bed, end],
+          ])
+        if (b > now)
+          planned.push({
+            id: "sleep:" + a,
+            kind: "sleep",
+            title: "作息中的睡眠时间",
+            start: Math.max(now, a),
+            end: b,
+          });
+    }
+    for (const block of planned.filter((b) => b.taskId)) {
+      const urgent = planned
+        .filter(
+          (b) =>
+            b.taskId &&
+            b.taskId !== block.taskId &&
+            b.priority > block.priority &&
+            b.start < block.end &&
+            b.end > block.start,
+        )
+        .sort((a, b) => a.start - b.start)[0];
+      const bedtime = planned
+        .filter(
+          (b) =>
+            b.kind === "sleep" && b.start < block.end && b.end > block.start,
+        )
+        .sort((a, b) => a.start - b.start)[0];
+      const stop = Math.min(
+        urgent ? Math.max(block.start, urgent.start) : block.end,
+        bedtime ? Math.max(block.start, bedtime.start) : block.end,
+      );
+      block.chartEnd = stop;
+      if (stop < block.end) {
+        block.interruptedAt = stop;
+        block.interruption =
+          bedtime && stop === bedtime.start ? "sleep" : "priority";
+      }
+    }
+    planned.sort(
+      (a, b) => a.start - b.start || (b.priority || 0) - (a.priority || 0),
+    );
+    const next =
+      planned
+        .filter((b) => b.taskId && b.state !== "doing" && b.chosenStart > now)
+        .sort((a, b) => a.chosenStart - b.chosenStart)[0] || null;
+    const life = time.search.life,
+      planning = life?.planner?.working || life?.ownDay?.working,
+      phase = life?.phase(now);
+    const idle = {
+      title: primary
+        ? "有主活动在继续"
+        : planning
+          ? "正在想自己的安排"
+          : phase?.key === "asleep"
+            ? "在睡觉"
+            : next
+              ? "这会儿还没有主活动"
+              : "这会儿没有正在推进的主活动",
+      reason: primary
+        ? "普通交流可以伴随进行"
+        : planning
+          ? "把想做的事、开始时间和投入时长想清楚"
+          : phase?.key === "asleep"
+            ? "醒来后再接着自己的安排"
+            : next
+              ? "下一项已经选好时间，之前可以聊天、歇着或随手折腾"
+              : paused.length
+                ? "有活动保留了续接位置，之后由她重新安排"
+                : unarranged.length
+                  ? "待办已经记下，等她选择具体时间"
+                  : "可以自己找件小事做，也可以选择歇着",
+      next,
+    };
+    return {
+      date,
+      zone,
+      start,
+      end,
+      now,
+      actual,
+      planned,
+      waiting,
+      unarranged,
+      paused,
+      idle,
+      interactions: today.interactions.map((p) => ({
+        id: p.id,
+        at: p.created,
+        taskId: p.task_id,
+      })),
+      note: "下方是她已选定的开始时间和这次想投入的时长。实际经过单独记录；提前完成、暂停或优先级切换后会保留原安排并重新选择。空白不代表已经在做什么。",
+    };
+  }
+}