luckytri 1.0.0

package/server/mind/time/executor.js

@@ -0,0 +1,512 @@
+import { randomUUID } from "node:crypto";
+import { localClock } from "../../core/conversation-cues.js";
+import { withFallback } from "../../core/model-manager.js";
+import { prompts, replyPrompt } from "../../core/persona-manager.js";
+import { evidence, hasCredential, text } from "../util.js";
+import { ACTIVITY_LABELS } from "./tasks.js";
+import { activityLabel, isPluginActivity, needsEnergy } from "./kinds.js";
+import { stepPlugin } from "./plugin-activity.js";
+import { executionBlock } from "./availability.js";
+
+const ACTIVITY_PROMPT =
+  '执行一个属于自己的实际活动步骤。write创作一个完整小段，已有草稿时只追加下一段，修改模式则提供修改后的正文；根据篇幅决定本篇是否结束，连载完成的是本章。read只能阅读input.reading实际提供的段落；think留下想法记录。不编造外部操作、游玩、通关或未提供的资料。虚构人物只属于作品，不能进入真实人物记忆。不输出隐藏推理。外部suggestion是别人的建议，你决定采纳或拒绝并保留理由，可以改变方向、暂停或完结项目。输出JSON {"done":false,"title":"标题","content":"最多1800字完整小段","summary":"情节摘要","next":"续接位置","bible":{"characters":"人物设定","world":"世界设定","threads":"未解决线索"},"feeling":{"feeling":"两三个字的心情","valence":0.2},"accepted":true,"reason":"自己的选择理由","projectState":"active|paused|complete","share":{"choice":"send|later|decline","reason":"分享选择"}}。完成本篇时done:true；休息/拒绝时没有content并说明reason。本步骤不发消息、不直接改变人格。';
+
+export class TimeExecutor {
+  constructor(life) {
+    this.life = life;
+    this.time = life.mind.time;
+    this.db = life.db;
+  }
+  run(now = this.life.now()) {
+    return this.time.attention.activity(() => this.step(now));
+  }
+  async step(now) {
+    const life = this.life,
+      mind = life.mind,
+      time = this.time;
+    time.tasks.sync(now);
+    if (
+      life.closed ||
+      life.busy ||
+      life.repo.store.settings().demo ||
+      !life.settings().solitude ||
+      life.phase(now).key === "asleep"
+    )
+      return null;
+    let task, chunk;
+    let primary = time.primary();
+    if (primary && !primary.lease) {
+      const urgent = time.tasks
+        .ready(now)
+        .find(
+          (t) =>
+            t.priority > primary.priority &&
+            !executionBlock(time, t, now) &&
+            (time.fixtureImmediate ||
+              life.planner.disabledForTest ||
+              (t.checkpoint.schedule?.chosenAt && !t.checkpoint.reschedule)),
+        );
+      if (urgent) {
+        time.tasks.control(
+          primary.id,
+          {
+            action: "pause",
+            readyAt: now + 60000,
+            reason: "先处理一件优先级更高的事，保留续接位置",
+          },
+          now,
+        );
+        time.event(
+          primary.id,
+          "preempted",
+          "更高优先级事项先做",
+          { forTask: urgent.id, checkpoint: primary.checkpoint.next || "" },
+          now,
+        );
+        primary = null;
+      }
+    }
+    for (const candidate of primary ? [primary] : time.tasks.ready(now)) {
+      if (candidate.next_step > now) continue;
+      if (
+        !time.fixtureImmediate &&
+        !life.planner.disabledForTest &&
+        (!candidate.checkpoint.schedule?.chosenAt ||
+          candidate.checkpoint.reschedule)
+      )
+        continue;
+      const block = executionBlock(time, candidate, now);
+      if (
+        block &&
+        block !== "来源已经撤销" &&
+        !(candidate.activity === "read" && block === "书架没有可读资料")
+      ) {
+        time.tasks.wait(
+          candidate,
+          block,
+          /选定|想具体|执行能力/.test(block)
+            ? Number.MAX_SAFE_INTEGER
+            : now + 10 * 60000,
+          now,
+        );
+        continue;
+      }
+      if (
+        candidate.checkpoint.pendingStep?.chunk &&
+        !this.db
+          .prepare("SELECT 1 FROM core_chunks WHERE id=?")
+          .get(candidate.checkpoint.pendingStep.chunk.id)
+      ) {
+        time.tasks.wait(
+          candidate,
+          "书架这段内容已不可用",
+          Number.MAX_SAFE_INTEGER,
+          now,
+        );
+        continue;
+      }
+      if (!time.allowed(candidate, now)) {
+        time.tasks.control(
+          candidate.id,
+          { action: "abandon", reason: "来源已经撤销" },
+          now,
+        );
+        continue;
+      }
+      if (
+        candidate.session_id &&
+        !life.chat.enabled(candidate.session_id, { simulated: false })
+      ) {
+        time.tasks.wait(candidate, "来源会话目前未启用", now + 60000, now);
+        continue;
+      }
+      if (
+        !candidate.checkpoint.pendingStep &&
+        !mind.budget.allows("inner", now)
+      ) {
+        time.tasks.wait(candidate, "今日独处预算不足", now + 3600000, now);
+        continue;
+      }
+      if (
+        needsEnergy(candidate.activity) &&
+        mind.affect.state(now).energy < 0.18
+      ) {
+        time.tasks.wait(
+          candidate,
+          "精力较低，先恢复一会儿再投入",
+          now + 10 * 60000,
+          now,
+        );
+        continue;
+      }
+      if (candidate.activity === "game") {
+        const blocked = candidate.checkpoint.sourceIds?.length
+          ? ""
+          : time.search.ready(now);
+        if (blocked) {
+          time.tasks.wait(candidate, blocked, now + 60000, now);
+          continue;
+        }
+      }
+      chunk =
+        candidate.checkpoint.pendingStep?.chunk ||
+        (candidate.activity === "read" ? mind.reading.next(now) : null);
+      if (candidate.activity === "read" && !chunk) {
+        time.tasks.wait(candidate, "书架没有可读资料", now, now);
+        continue;
+      }
+      task = candidate;
+      break;
+    }
+    if (!task) return time.sharing.run(life, now);
+    let profile;
+    try {
+      if (!task.checkpoint.pendingStep) profile = life.profile();
+    } catch {
+      time.tasks.wait(task, "等待可用模型", now + 60000, now);
+      return null;
+    }
+    task = time.start(task, now);
+    if (!task) return null;
+    const runId = life.run(
+        "activity",
+        `${activityLabel(task.activity, ACTIVITY_LABELS[task.activity] || "活动")}：${task.title}`,
+      ),
+      trace = life.repo.trace("__mind__", "activity"),
+      version = mind.nature.version();
+    let status = "empty",
+      reason = "这次还不想做",
+      creation = null;
+    try {
+      if (task.activity === "game") {
+        const outcome = await time.games.step(task, life, trace, runId);
+        status = outcome.status;
+        reason = outcome.reason;
+        return { ...outcome, runId };
+      }
+      if (isPluginActivity(task.activity)) {
+        const outcome = await stepPlugin(task, life, trace, runId);
+        status = outcome.status;
+        reason = outcome.reason;
+        return { ...outcome, runId };
+      }
+      const nature = mind.traits.effective(mind.nature.current(now), now);
+      const pending = task.checkpoint.pendingStep;
+      if (pending && time.clock.remaining(task, now) > 0) {
+        status = "engaged";
+        reason = "接着做这一段";
+        time.clock.release(task, task.checkpoint, now);
+        return {
+          status: "engaged",
+          reason: "接着做这一段",
+          task: task.id,
+          runId,
+        };
+      }
+      const result =
+        pending?.result ||
+        (await withFallback(
+          life.chat.models,
+          life.chat.fallbackFor(null, profile, trace),
+        ).call(
+          profile,
+          "reflection",
+          replyPrompt(
+            nature,
+            {
+              ...prompts(life.repo),
+              activity:
+                ACTIVITY_PROMPT +
+                '\n为本段行动估计通常需要的投入时长，输出duration:{minutes:15,basis:"按本段内容与行动估计的理由"}。只估计这一段阅读、写作或思考需要的时间，不用API处理秒数；她的实际节奏会按统一速度稍作加快。',
+            },
+            "activity",
+          ),
+          {
+            clock: localClock(now, mind.timeZone()),
+            activity: task.activity,
+            affect: mind.affect.state(now),
+            task: {
+              id: task.id,
+              title: task.title,
+              why: task.why,
+              checkpoint: task.checkpoint,
+            },
+            plan: {
+              ref: task.anticipation_id
+                ? `a:${task.anticipation_id}`
+                : task.sources[0],
+              content: task.title,
+            },
+            self: life
+              .selfView(now, { room: task.session_id || "" })
+              .slice(0, 8),
+            ...(chunk ? { reading: mind.reading.passage(chunk) } : {}),
+            creation: time.works.context(task),
+            currentLife: time.view({ session: task.session_id, now }),
+          },
+          trace,
+        ));
+      const finished = life.now();
+      if (
+        task.activity === "write" &&
+        result?.done === true &&
+        /(?:未完待续|[（(]待续[）)]|尚未完成|只是开头草稿)\s*[。.!！]?\s*$/.test(
+          String(result.content || ""),
+        )
+      )
+        result.done = false;
+      if (
+        life.closed ||
+        mind.nature.version() !== version ||
+        !time.valid(task)
+      ) {
+        status = "cancelled";
+        reason = "任务或服务状态已经变化";
+      } else if (
+        (result?.done === false && !result.content) ||
+        result?.skip ||
+        (task.kind === "suggestion" && result?.accepted === false)
+      ) {
+        reason = text(result.reason, 120) || reason;
+        if (task.kind === "suggestion" && result?.accepted === false) {
+          time.event(task.id, "suggestion-declined", reason, {}, finished);
+          time.tasks.control(task.id, { action: "abandon", reason }, finished);
+        } else
+          time.tasks.control(
+            task.id,
+            {
+              action: "pause",
+              readyAt: finished + time.settings().breakMinutes * 60000,
+              reason,
+            },
+            finished,
+          );
+      } else {
+        const title = text(result?.title, 80),
+          content = text(result?.content, 1800);
+        if (
+          typeof result?.done !== "boolean" ||
+          !title ||
+          !content ||
+          hasCredential(title + content)
+        )
+          throw Error("活动成果格式无效");
+        const sources = evidence([
+          ...(task.anticipation_id ? [`a:${task.anticipation_id}`] : []),
+          ...(chunk ? [`r:${chunk.id}`] : []),
+          ...task.sources,
+        ]);
+        if (!time.fixtureImmediate && !pending) {
+          this.db.exec("SAVEPOINT paced_draft");
+          try {
+            if (task.kind === "suggestion")
+              time.event(
+                task.id,
+                "suggestion-accepted",
+                text(result.reason, 240),
+                {},
+                finished,
+              );
+            const work = time.works.save(
+              task,
+              { ...result, done: false },
+              { sources, runId, now: finished },
+            );
+            const checkpoint = time.tasks.get(task.id).checkpoint;
+            time.clock.release(
+              task,
+              {
+                ...checkpoint,
+                activityClock: time.clock.plan(task, result.duration, finished),
+                pendingStep: {
+                  result: { ...result, title, content },
+                  workId: work.id,
+                  chunk,
+                  sources,
+                  runId,
+                },
+                next: result.next || "接着推敲与整理这一段",
+              },
+              finished,
+            );
+            status = "draft";
+            reason = "草稿已保存，接着完成这一段";
+            return { status, reason, task: task.id, runId, workId: work.id };
+          } catch (error) {
+            this.db.exec("ROLLBACK TO paced_draft");
+            throw error;
+          } finally {
+            this.db.exec("RELEASE paced_draft");
+          }
+        }
+        this.db.exec("SAVEPOINT time_execution");
+        try {
+          if (task.kind === "suggestion" && !pending)
+            time.event(
+              task.id,
+              "suggestion-accepted",
+              text(result.reason, 240),
+              {},
+              finished,
+            );
+          if (pending) {
+            const checkpoint = {
+              ...task.checkpoint,
+              activityClock: {
+                ...task.checkpoint.activityClock,
+                phase: "finished",
+              },
+            };
+            delete checkpoint.pendingStep;
+            this.db
+              .prepare("UPDATE mind_time_tasks SET checkpoint=? WHERE id=?")
+              .run(JSON.stringify(checkpoint), task.id);
+          }
+          const work = pending
+            ? time.works.settle(task, pending.workId, result.done, finished)
+            : time.works.save(task, result, {
+                sources,
+                runId,
+                now: finished,
+              });
+          if (chunk)
+            mind.reading.record(chunk, text(content, 120), runId, finished);
+          if (result.done) {
+            creation = randomUUID();
+            this.db
+              .prepare(
+                "INSERT INTO mind_creations VALUES (?,?,?,?,?,?,?,?,?,?)",
+              )
+              .run(
+                creation,
+                finished,
+                task.anticipation_id || task.id,
+                task.activity,
+                title,
+                work.content,
+                JSON.stringify(sources),
+                task.session_id,
+                task.discretion,
+                runId,
+              );
+            mind.thoughts.add({
+              // Narrative remains in the work. Only the act becomes an experience.
+              kind: "reflection",
+              content:
+                task.activity === "write"
+                  ? `我完成了《${title}》的第 ${work.ordinal} 篇，正文保存在作品库；其中情节和人物是创作。`
+                  : text(`${title}：${content}`, 600),
+              sources: evidence([`x:${task.id}`, ...sources]),
+              sessions: task.session_id ? [task.session_id] : [],
+              runId,
+              time: finished,
+              importance: 0.4,
+            });
+            time.complete(
+              task,
+              { creation, workId: work.id, sources },
+              finished,
+            );
+            this.db
+              .prepare(
+                "UPDATE mind_time_works SET legacy_creation=? WHERE id=?",
+              )
+              .run(creation, work.id);
+            const project = time.works.project(task.project_id);
+            if (
+              project.serial &&
+              result.next &&
+              (!result.projectState || result.projectState === "active")
+            )
+              time.tasks.add(
+                {
+                  kind: "plan",
+                  activity: task.activity,
+                  title: `接续《${project.title}》第 ${work.ordinal + 1} 篇`,
+                  why: text(result.reason || result.next, 240),
+                  sources: [`x:${task.id}`],
+                  session: task.session_id,
+                  discretion: task.discretion,
+                  projectId: project.id,
+                  readyAt: finished + time.settings().breakMinutes * 60000,
+                  activeOnly: true,
+                },
+                finished,
+              );
+            if (result.share?.choice && task.session_id)
+              time.sharing.choose(
+                work.id,
+                task.session_id,
+                result.share,
+                finished,
+              );
+          } else time.progress(task, work, result, finished);
+          if (result.feeling?.feeling)
+            mind.affect.feel({
+              ...result.feeling,
+              intensity: 0.2,
+              cause: `做自己的${activityLabel(task.activity, ACTIVITY_LABELS[task.activity] || "事")}时的感受`,
+              sources: [`x:${task.id}`],
+              session: task.session_id,
+              origin: "activity",
+              time: finished,
+            });
+          if (["paused", "complete"].includes(result.projectState))
+            this.db
+              .prepare("UPDATE mind_time_projects SET state=? WHERE id=?")
+              .run(result.projectState, task.project_id);
+          if (result.projectState === "paused" && !result.done)
+            time.tasks.control(
+              task.id,
+              {
+                action: "pause",
+                reason: text(result.reason, 240) || "自己选择暂时放下这个项目",
+              },
+              finished,
+            );
+          this.db.exec("RELEASE time_execution");
+        } catch (error) {
+          this.db.exec("ROLLBACK TO time_execution");
+          this.db.exec("RELEASE time_execution");
+          creation = null;
+          throw error;
+        }
+        status = result.done ? "written" : "draft";
+        reason = `${activityLabel(task.activity, ACTIVITY_LABELS[task.activity] || "活动")}，保存了《${title}》${result.done ? "完成稿" : "草稿"}`;
+      }
+    } catch (error) {
+      status = "error";
+      reason = text(error.message, 200);
+      trace.error = reason;
+      if (time.valid(task))
+        time.tasks.wait(task, reason, life.now() + 15 * 60000, life.now());
+    } finally {
+      if (time.valid(task))
+        time.tasks.control(
+          task.id,
+          {
+            action: "pause",
+            readyAt: life.now() + time.settings().breakMinutes * 60000,
+            reason,
+          },
+          life.now(),
+        );
+      trace.reason = reason;
+      life.chat.finishQuietly(trace, status === "error" ? "error" : "complete");
+      life.end(runId, status, reason, trace, {
+        plan: task.anticipation_id,
+        task: task.id,
+        activity: task.activity,
+        creation,
+      });
+    }
+    return {
+      status,
+      reason,
+      runId,
+      activity: task.activity,
+      creation,
+      task: task.id,
+    };
+  }
+}

package/server/mind/time/experiences.js

@@ -0,0 +1,128 @@
+import { parse, text } from "../util.js";
+import { gameText } from "./presentation.js";
+import { activityLabel } from "./kinds.js";
+
+const labels = {
+  game: "游玩",
+  write: "创作",
+  read: "阅读",
+  think: "独处思考",
+  research: "探索",
+};
+const generic =
+  /^(?:留下了实际成果|玩过这一段，留下自己的感受|保存位置，下次接着做)$/;
+
+// Events remain the audit trail. The library shows each saved outcome once,
+// using its historical version rather than today's task or latest manuscript.
+export function experiences(db, { limit = 40, offset = 0, q = "" } = {}) {
+  const rows = db
+    .prepare(
+      `
+    WITH drafts AS MATERIALIZED (
+      SELECT id,created,reason,json_extract(data,'$.workId') work_id,
+        json_extract(data,'$.version') version FROM mind_time_events WHERE kind='draft'
+    ), linked AS (
+      SELECT e.*,t.activity,t.title task_title,w.id work_id,w.project_id,
+        p.title project_title,p.kind project_kind,v.version,v.title work_title,
+        v.summary,substr(v.content,1,300) excerpt,length(v.content) characters,
+        v.provenance,
+        (SELECT reason FROM drafts d WHERE d.work_id=w.id AND d.version=v.version
+          AND d.created<=e.created AND d.id<e.id
+          ORDER BY d.created DESC,d.id DESC LIMIT 1) saved_reason
+      FROM mind_time_events e
+      LEFT JOIN mind_time_tasks t ON t.id=e.task_id
+      LEFT JOIN mind_time_works w ON w.id=COALESCE(json_extract(e.data,'$.workId'),
+        (SELECT id FROM mind_time_works WHERE legacy_creation=json_extract(e.data,'$.creation')))
+      LEFT JOIN mind_time_projects p ON p.id=w.project_id
+      LEFT JOIN mind_time_versions v ON v.work_id=w.id AND v.created<=e.created
+        AND v.version=COALESCE(json_extract(e.data,'$.version'),
+          (SELECT version FROM drafts d WHERE d.work_id=w.id AND d.created<=e.created AND d.id<e.id
+            ORDER BY d.created DESC,d.id DESC LIMIT 1),
+          CASE WHEN w.legacy_creation IS NOT NULL THEN
+            (SELECT MAX(version) FROM mind_time_versions WHERE work_id=w.id AND created<=e.created) END)
+      WHERE e.kind IN ('reference-experience','done','checkpoint')
+    ), grouped AS (
+      SELECT *,ROW_NUMBER() OVER (PARTITION BY
+        CASE WHEN version IS NOT NULL THEN work_id||':'||version ELSE 'event:'||id END
+        ORDER BY CASE kind WHEN 'reference-experience' THEN 3 WHEN 'done' THEN 2 ELSE 1 END DESC,
+          created DESC,id DESC) position,
+        MAX(kind='done') OVER (PARTITION BY
+          CASE WHEN version IS NOT NULL THEN work_id||':'||version ELSE 'event:'||id END) completed
+      FROM linked
+    )
+    SELECT * FROM grouped WHERE position=1
+      AND (COALESCE(work_title,'') LIKE ? OR COALESCE(task_title,'') LIKE ?
+        OR COALESCE(project_title,'') LIKE ? OR COALESCE(summary,'') LIKE ?)
+    ORDER BY created DESC,id DESC LIMIT ? OFFSET ?
+  `,
+    )
+    .all(
+      ...Array(4).fill("%" + text(q, 80) + "%"),
+      Math.max(1, Math.min(100, Number(limit) || 40)),
+      Math.max(0, Number(offset) || 0),
+    );
+  const sources = db.prepare(
+    "SELECT id,title,kind,url FROM mind_time_sources WHERE id=?",
+  );
+  return rows.map((row) => {
+    const data = parse(row.data, {}),
+      provenance = parse(row.provenance, {});
+    const activity =
+      row.activity ||
+      row.project_kind ||
+      (row.kind === "reference-experience" ? "game" : "other");
+    const clean = (value) =>
+      activity === "game" ? gameText(value) : String(value || "").trim();
+    const title =
+      clean(row.work_title || row.task_title || row.project_title) ||
+      "这次活动的记录";
+    const summary = text(
+      clean(
+        row.summary ||
+          row.excerpt ||
+          (!generic.test(row.reason) ? row.reason : ""),
+      ),
+      260,
+    );
+    const sourceIds = [
+      ...new Set([
+        ...(Array.isArray(data.sourceIds) ? data.sourceIds : []),
+        ...(Array.isArray(provenance.sourceIds) ? provenance.sourceIds : []),
+      ]),
+    ];
+    return {
+      id: row.id,
+      created: row.created,
+      task_id: row.task_id,
+      kind: row.kind,
+      title,
+      summary,
+      activity,
+      label: labels[activity] || activityLabel(activity),
+      project: row.project_id
+        ? { id: row.project_id, title: clean(row.project_title) }
+        : null,
+      work: row.version
+        ? {
+            id: row.work_id,
+            version: row.version,
+            characters: row.characters,
+            state:
+              row.completed ||
+              row.kind === "reference-experience" ||
+              row.saved_reason === "保存完成稿"
+                ? "complete"
+                : "draft",
+          }
+        : null,
+      materials: sourceIds.map((id) => sources.get(id)).filter(Boolean),
+      // Compatibility for older clients; never substitute a future manuscript.
+      reason: row.reason,
+      data: {
+        ...data,
+        workId: row.version ? row.work_id : null,
+        version: row.version,
+      },
+    };
+  });
+}