luckytri 1.0.7 → 1.0.9

package/server/core/turn.js

@@ -1,10 +1,37 @@
 import { replyFocus } from "./conversation-cues.js";
 import { INITIATIVE_PROMPT } from "../mind/initiative.js";
 import { initiativeContext } from "./initiative-context.js";
-import { conversationGrounding } from "./conversation-grounding.js";
-import { currentExchange, explicitStop } from "./dialogue-context.js";
+import {
+  conversationGrounding,
+  prefersSingleBubble,
+} from "./conversation-grounding.js";
+import {
+  currentExchange,
+  dialogueContext,
+  explicitStop,
+} from "./dialogue-context.js";
+import { readerQuestions } from "./reader-check.js";
+import {
+  botExchange,
+  CONTRIBUTION_CHECK,
+  CONTRIBUTION_REPAIR,
+} from "./contribution-check.js";
+import {
+  claimsLivedAction,
+  EXPRESSION_GROUNDING,
+} from "../mind/expression-grounding.js";
 
 export const CHOICES = ["speak", "react", "decline", "silent"];
+const INTENT_KINDS = [
+  "question",
+  "proposal",
+  "feeling",
+  "sharing",
+  "correction",
+  "greeting",
+  "closing",
+  "other",
+];
 const LEGACY = {
   REPLY: "speak",
   MULTI_MESSAGE: "speak",
@@ -12,8 +39,22 @@ const LEGACY = {
   SILENT: "silent",
 };
 
-export function maxBubbles(choice) {
-  return choice === "speak" ? 3 : 1;
+export function maxBubbles(choice, snapshot) {
+  if (choice !== "speak") return 1;
+  return prefersSingleBubble(snapshot || {}) ? 1 : 3;
+}
+
+export function joinBubbleParts(parts) {
+  return parts.reduce((joined, part) => {
+    if (!joined) return part;
+    if (/^(?:[-*•]|\d+[.)、])\s/u.test(part)) return `${joined}\n${part}`;
+    if (/[A-Za-z0-9]$/u.test(joined) && /^[A-Za-z0-9]/u.test(part))
+      return `${joined} ${part}`;
+    if (/[，、：:]$/u.test(joined) || /^[，、；;]/u.test(part))
+      return `${joined}${part}`;
+    if (/[。！？!?；;…）」』】》]$/u.test(joined)) return `${joined}${part}`;
+    return `${joined}，${part}`;
+  }, "");
 }
 
 const ACTION_NAME = /^[a-z][a-z0-9-]*\.[a-z][a-z0-9-]{0,40}$/;
@@ -42,7 +83,7 @@ export function normalizeAct(raw, trace) {
 
 export function recallWording(snapshot) {
   if (snapshot.initiative) return null;
-  const continuity = snapshot.inner?.continuity;
+  const continuity = dialogueContext(snapshot).inner?.continuity;
   const notes = [];
   if (
     continuity?.people?.some(
@@ -68,7 +109,8 @@ export function recallWording(snapshot) {
 }
 
 // One look at the conversation: what it means to her, how it moves her, and
-// whether and how she answers. Comes back as a single model call.
+// whether and how she answers. A bot exchange gets at most one repair pass
+// when its first draft repeats old promises instead of answering new content.
 export async function takeTurn(
   models,
   profile,
@@ -77,12 +119,6 @@ export async function takeTurn(
   trace,
   extra = {},
 ) {
-  const {
-    sourceRows: _rows,
-    batch: _batch,
-    persona: _persona,
-    ...context
-  } = snapshot;
   const images = extra.images || [];
   const initiating =
     extra.occasion && ["presence", "outreach"].includes(extra.occasion.type);
@@ -93,35 +129,179 @@ export async function takeTurn(
       : snapshot.unavailableImages?.length
         ? "本轮图片没有读取成功，不要编造画面内容。"
         : undefined;
-  return models.call(
-    profile,
-    "turn",
+  const turnSystem =
     extra.occasion && ["presence", "outreach"].includes(extra.occasion.type)
       ? `${system}\n${INITIATIVE_PROMPT}`
-      : system,
-    {
-      context: initiating
-        ? initiativeContext(snapshot, extra.occasion)
-        : { ...context, grounding: conversationGrounding(snapshot) },
-      ...(extra.occasion
-        ? {
-            occasion: initiating
-              ? {
-                  ...extra.occasion,
-                  initiative: initiativeContext(snapshot, extra.occasion)
-                    .initiative,
-                }
-              : extra.occasion,
-          }
-        : {}),
-      ...(imageGuide ? { imageGuide } : {}),
-      ...(extra.pressure ? { pressure: extra.pressure } : {}),
-      ...(recallWording(snapshot) ? { guidance: recallWording(snapshot) } : {}),
-      ...(!initiating ? { exchange: currentExchange(snapshot) } : {}),
-    },
+      : system;
+  const turnInput = {
+    context: initiating
+      ? initiativeContext(snapshot, extra.occasion)
+      : dialogueContext(snapshot),
+    ...(extra.occasion
+      ? {
+          occasion: initiating
+            ? {
+                ...extra.occasion,
+                initiative: initiativeContext(snapshot, extra.occasion)
+                  .initiative,
+              }
+            : extra.occasion,
+        }
+      : {}),
+    ...(imageGuide ? { imageGuide } : {}),
+    ...(extra.pressure ? { pressure: extra.pressure } : {}),
+    ...(recallWording(snapshot) ? { guidance: recallWording(snapshot) } : {}),
+    ...(!initiating ? { exchange: currentExchange(snapshot) } : {}),
+  };
+  let raw = await models.call(
+    profile,
+    "turn",
+    turnSystem,
+    turnInput,
     trace,
     images,
   );
+  const words = (
+    Array.isArray(raw?.bubbles) ? raw.bubbles : [raw?.bubbles]
+  ).filter((word) => typeof word === "string");
+  if (
+    snapshot.initiative &&
+    raw?.choice === "speak" &&
+    claimsLivedAction(words.join("\n"))
+  ) {
+    // Reject a fictional action before experience() can turn its appraisal
+    // into a new memory. A self-initiated message has no unanswered request
+    // that would justify filling in a different story through rewrites.
+    let grounded;
+    try {
+      grounded = await models.call(
+        profile,
+        "validation",
+        EXPRESSION_GROUNDING,
+        {
+          candidate: { words },
+          currentLife: snapshot.inner?.currentLife || {},
+          notes: [],
+          self: [],
+        },
+        trace,
+      );
+    } catch (error) {
+      trace?.steps?.push(`主动经历核对暂不可用，先不分享：${error.message}`);
+    }
+    if (trace)
+      trace.experienceReview = {
+        words: [...words],
+        ok: grounded?.ok === true,
+        reason: grounded?.reason || "实际经历尚未核实",
+      };
+    if (grounded?.ok !== true)
+      return {
+        ...raw,
+        choice: "silent",
+        bubbles: [],
+        appraisal: "",
+        feelings: [],
+        bonds: [],
+        contribution: {
+          kind: "none",
+          point: "旧草稿中的新行动尚无实际记录支持",
+        },
+        reason: "这段念头的经历依据还没有核实，先留在自己这里",
+      };
+  }
+  const exchange = botExchange(snapshot, raw);
+  if (
+    exchange &&
+    (raw.choice === "speak" || raw.choice === "react") &&
+    raw.contribution?.kind !== "none"
+  ) {
+    try {
+      let review = await models.call(
+        profile,
+        "validation",
+        CONTRIBUTION_CHECK,
+        {
+          botExchange: exchange,
+          reply: raw.bubbles || [],
+          plannedPoint: raw.contribution?.point || "",
+        },
+        trace,
+      );
+      if (trace && typeof review.hasContribution === "boolean")
+        trace.contributionReview = review;
+      if (review.hasContribution === false && review.shouldRepair === true) {
+        trace?.steps?.push("新问题或新段落被上一稿漏接，按当前内容重新想一次");
+        try {
+          const repaired = await models.call(
+            profile,
+            "turn",
+            `${turnSystem}\n${CONTRIBUTION_REPAIR}`,
+            {
+              ...turnInput,
+              contributionRepair: {
+                previousReply: raw.bubbles || [],
+              },
+            },
+            trace,
+            images,
+          );
+          const repairedExchange = botExchange(snapshot, repaired);
+          if (
+            repairedExchange &&
+            ["speak", "react"].includes(repaired.choice) &&
+            repaired.contribution?.kind !== "none"
+          ) {
+            const revisedReview = await models.call(
+              profile,
+              "validation",
+              CONTRIBUTION_CHECK,
+              {
+                botExchange: repairedExchange,
+                reply: repaired.bubbles || [],
+                plannedPoint: repaired.contribution?.point || "",
+                repairAttempt: true,
+              },
+              trace,
+            );
+            review = revisedReview;
+          }
+          if (trace) {
+            trace.contributionReview = review;
+            trace.contributionRepair = {
+              attempted: true,
+              succeeded: review.hasContribution === true,
+            };
+          }
+          if (review.hasContribution === true) return repaired;
+        } catch (error) {
+          trace?.steps?.push(`按新内容重答失败，本轮先不发：${error.message}`);
+        }
+        return {
+          ...raw,
+          choice: "silent",
+          bubbles: [],
+          feelings: [],
+          bonds: [],
+          contribution: { kind: "none", point: "新内容没有形成可发送的回复" },
+        };
+      }
+      if (review.hasContribution === false)
+        return {
+          ...raw,
+          choice: "silent",
+          bubbles: [],
+          feelings: [],
+          bonds: [],
+          contribution: { kind: "none", point: "没有新的内容，不再换词确认" },
+        };
+    } catch (error) {
+      trace?.steps?.push(
+        `接话内容核对暂不可用，继续原有校验：${error.message}`,
+      );
+    }
+  }
+  return raw;
 }
 
 const ids = (value) =>
@@ -148,6 +328,17 @@ export function normalizeTurn(raw, snapshot, trace) {
       .slice(-1)
       .map((m) => m.id);
   }
+  if (
+    choice === "react" &&
+    readerQuestions(snapshot, {
+      choice,
+      targetMessageIds: targets,
+      understanding: raw.understanding,
+    }).some((q) => targets.includes(q.id))
+  ) {
+    choice = "speak";
+    trace?.steps?.push("对方在要求解释，保留完整回答空间，不按极短反应截断");
+  }
   let bubbles = [];
   if (Array.isArray(raw.bubbles)) bubbles = raw.bubbles;
   else if (typeof raw.bubbles === "string") bubbles = [raw.bubbles];
@@ -161,6 +352,26 @@ export function normalizeTurn(raw, snapshot, trace) {
     .filter((x) => typeof x === "string")
     .map((x) => x.trim())
     .filter(Boolean);
+  if (choice === "react" && bubbles.length === 1 && bubbles[0].length > 20) {
+    choice = "speak";
+    trace?.steps?.push(
+      "这是一句完整回应，按正常发言保留，不为短反应标签改写原意",
+    );
+  }
+  const bubbleLimit = maxBubbles(choice, snapshot);
+  if (bubbles.length > bubbleLimit) {
+    if (choice === "speak" && bubbleLimit === 1) {
+      bubbles = [joinBubbleParts(bubbles)];
+      trace?.steps?.push("根据对方的偏好，把连续补充合成一条完整消息");
+    } else {
+      bubbles = bubbles.slice(0, bubbleLimit);
+      trace?.steps?.push(
+        choice === "react"
+          ? "简短反应只留第一条气泡"
+          : "回复超过当前对方的分段偏好，已收束到允许的条数",
+      );
+    }
+  }
   if (choice === "silent") bubbles = [];
   const crisisIds = ids(raw.crisis?.messageIds).filter((id) =>
     batchIds.has(id),
@@ -177,12 +388,33 @@ export function normalizeTurn(raw, snapshot, trace) {
     bubbles = [];
     trace?.steps?.push("有人可能处在危机里，底线要求认真回应");
   }
+  const grounding = conversationGrounding(snapshot);
+  const botFollowupLimit =
+    !crisis && !snapshot.initiative && grounding.botFollowupLimit;
   const botLoop =
-    !crisis && !snapshot.initiative && conversationGrounding(snapshot).botLoop;
-  if (botLoop) {
+    !crisis &&
+    !snapshot.initiative &&
+    (grounding.botLoop ||
+      (raw.contribution?.kind === "none" &&
+        !raw.act &&
+        !raw.share &&
+        !["chat", "rest"].includes(raw.attention?.action) &&
+        batch.length > 0 &&
+        batch.filter((m) => m.role === "user").length > 0 &&
+        batch
+          .filter((m) => m.role === "user")
+          .every((m) =>
+            conversationGrounding(snapshot).botMessageIds.includes(m.id),
+          )));
+  const botYield = botLoop || botFollowupLimit;
+  if (botYield) {
     choice = "silent";
     bubbles = [];
-    trace?.steps?.push("机器人连续确认没有新内容，这段对话在此收住");
+    trace?.steps?.push(
+      botFollowupLimit
+        ? "机器人之间已经连续说过两轮，这次没有新的直接提问或纠正，先留出空间"
+        : "机器人连续确认没有新内容，这段对话在此收住",
+    );
   }
   const stopped = !crisis && explicitStop(snapshot);
   if (stopped) {
@@ -197,7 +429,7 @@ export function normalizeTurn(raw, snapshot, trace) {
   return {
     choice,
     share:
-      !botLoop &&
+      !botYield &&
       !stopped &&
       raw.share &&
       ["send", "later", "decline"].includes(raw.share.choice)
@@ -208,7 +440,7 @@ export function normalizeTurn(raw, snapshot, trace) {
           }
         : null,
     attention:
-      !botLoop &&
+      !botYield &&
       raw.attention &&
       ["continue", "chat", "rest"].includes(raw.attention.action)
         ? {
@@ -216,16 +448,23 @@ export function normalizeTurn(raw, snapshot, trace) {
             reason: text(raw.attention.reason, 120),
           }
         : { action: "continue" },
-    appraisal: botLoop
-      ? "对方在确认先前的话，没有新的内容。"
+    appraisal: botYield
+      ? botFollowupLimit
+        ? "这段互答已经有来有回，先给聊天留点空间。"
+        : "对方在确认先前的话，没有新的内容。"
       : text(raw.appraisal, 200),
-    reason: botLoop
-      ? "这段交流已经结束，先收住。"
+    reason: botYield
+      ? botFollowupLimit
+        ? "连续互答两轮，眼下没有直接问题或纠正，先给群里留点空间。"
+        : "这段交流已经结束，先收住。"
       : text(raw.reason || raw.appraisal, 300) || "此刻的判断",
-    topic: botLoop ? "交流结束" : text(raw.topic, 40),
+    topic: botYield ? "暂时停一下" : text(raw.topic, 40),
     ...(raw.understanding && typeof raw.understanding === "object"
       ? {
           understanding: {
+            ...(INTENT_KINDS.includes(raw.understanding.kind)
+              ? { kind: raw.understanding.kind }
+              : {}),
             messageIds: ids(raw.understanding.messageIds).filter((id) =>
               batchIds.has(id),
             ),
@@ -233,6 +472,14 @@ export function normalizeTurn(raw, snapshot, trace) {
           },
         }
       : {}),
+    ...(raw.contribution && typeof raw.contribution === "object"
+      ? {
+          contribution: {
+            kind: text(raw.contribution.kind, 20),
+            point: text(raw.contribution.point, 180),
+          },
+        }
+      : {}),
     targetMessageIds: targets,
     targetUserIds: [
       ...new Set(
@@ -242,17 +489,17 @@ export function normalizeTurn(raw, snapshot, trace) {
       ),
     ],
     evidenceIds: ids(raw.evidenceIds).filter((id) => known.has(id)),
-    feelings: (Array.isArray(raw.feelings) && !botLoop ? raw.feelings : [])
+    feelings: (Array.isArray(raw.feelings) && !botYield ? raw.feelings : [])
       .filter((f) => f && typeof f.feeling === "string")
       .slice(0, 3),
-    bonds: (Array.isArray(raw.bonds) && !botLoop ? raw.bonds : [])
+    bonds: (Array.isArray(raw.bonds) && !botYield ? raw.bonds : [])
       .filter((b) => b && b.userId != null && typeof b.change === "string")
       .map((b) => ({ ...b, evidence: ids(b.evidence) }))
       .slice(0, 4),
     crisis: crisis ? { clear: true, messageIds: crisisIds } : { clear: false },
-    act: botLoop || stopped ? null : normalizeAct(raw.act, trace),
-    bubbles: bubbles.slice(0, maxBubbles(choice)),
-    maxBubbles: maxBubbles(choice),
+    act: botYield || stopped ? null : normalizeAct(raw.act, trace),
+    bubbles: bubbles.slice(0, bubbleLimit),
+    maxBubbles: bubbleLimit,
   };
 }
 

package/server/i18n/decisions.js

@@ -27,6 +27,10 @@ export const DECISIONS = {
     "Context compression failed; it will retry automatically",
 
   // orchestrator, delivery
+  "删去未通过检查的多余末尾气泡，保留已通过全部校验的原答复":
+    "Removed the rejected trailing bubbles and kept the original answer that passed every check",
+  "这段念头的经历依据还没有核实，先留在自己这里":
+    "The experience behind this thought is not verified yet; keeping it private for now",
   "有一个备用模型档案不存在，已跳过":
     "A backup model profile does not exist; skipped",
   "引用消息未能恢复，保留 unknown，不认领对象":
@@ -173,6 +177,18 @@ export const DECISIONS = {
 };
 
 export const DECISION_PATTERNS = [
+  [
+    "主动经历核对暂不可用，先不分享：{0}",
+    "The proactive experience check is unavailable; holding the message: {0}",
+  ],
+  [
+    "接话内容核对暂不可用，继续原有校验：{0}",
+    "The contribution check is unavailable; continuing the existing checks: {0}",
+  ],
+  [
+    "主动消息声称的新行动尚无实际活动记录支持：{0}",
+    "The new action claimed by this proactive message lacks activity records: {0}",
+  ],
   ["整理了 {0} 段语境摘要", "Sorted {0} context summaries"],
   ["QQ 用户·{0}", "QQ user·{0}"],
   ["读取 QQ {0} 失败：{1}", "Reading QQ {0} failed: {1}"],

package/server/i18n/errors.js

@@ -2,6 +2,8 @@
 // key, exactly as the code writes it. `{0}` stands for a value the code puts
 // into the message; patterns are used when a message carries one.
 export const ERRORS = {
+  "JSON 同一对象含重复字段，不能确定哪份内容有效":
+    "A JSON object contains duplicate fields; the intended value is ambiguous",
   "写日记期间关系记录已变化，本次旧稿未保存，下次按新认识整理":
     "Relationships changed while writing the diary; the old draft was not saved and the next attempt will use the new knowledge",
   "写回顾期间关系记录已变化，本次旧稿未保存，下次按新认识整理":
@@ -457,6 +459,8 @@ export const ERRORS = {
   "正在推进活动步骤，请稍后测试":
     "An activity step is in progress. Test again shortly.",
   只有真实完成稿可以交付: "Only a genuinely finished piece can be delivered",
+  "这篇记录引用了与作品无关的资料，不能作为游戏阅读进度分享":
+    "This note uses material unrelated to the work and cannot be shared as reading progress",
   正文包含其他会话的私下内容:
     "The text contains private content from another session",
   作品来源不允许在此会话分享:

package/server/i18n/labels.js

@@ -3,6 +3,10 @@
 // key, exactly as the code writes it. Only a whole string that equals a key is
 // translated, so what she writes herself is never touched.
 export const LABELS = {
+  等待约定的正文或资料: "Waiting for the agreed manuscript or material",
+  等待来稿的阅读约定不能当成写作执行:
+    "A promise to read an incoming manuscript cannot run as writing",
+  指定的正文还不可阅读: "The specified manuscript is not available to read yet",
   存在运行伴随文件: "Runtime sidecar files exist",
   近期自动恢复点: "Recent automatic restore point",
   // feedback.js
@@ -608,7 +612,6 @@ export const LABEL_PATTERNS = [
     "Touched by others' words {0} times; last {1}, and she {2}",
   ],
   ["第 {0} / {1} 段", "Passage {0} / {1}"],
-  ["主题片段 {0}", "Topic passage {0}"],
   [
     "正在玩，本段预计约 {0} 分钟",
     "Playing; this span should take about {0} min",
@@ -618,10 +621,8 @@ export const LABEL_PATTERNS = [
     "I finished piece {1} of “{0}”. The text is saved in the works library; the plot and characters in it are made up.",
   ],
   ["接续《{0}》第 {1} 篇", "Continue piece {1} of “{0}”"],
-  [
-    "玩过第 {0} 段，留下自己的游玩记录",
-    "Played passage {0} and left her own play record",
-  ],
+  ["已留下《{0}》这篇阅读笔记", "Saved a reading note titled “{0}”"],
+  ["已接触一些游戏资料", "Has read some game reference material"],
   ["{0}，已保存 {1} 字完成稿", "{0}, saved a finished piece of {1} characters"],
   ["{0}，已保存 {1} 字正文", "{0}, saved {1} characters of text"],
   [

package/server/i18n/models.js

@@ -23,6 +23,7 @@ export const MODEL_LABELS = {
 
   // providers and labels
   火山方舟: "Volcengine Ark",
+  "火山方舟 Agent Plan": "Volcengine Ark Agent Plan",
   "火山方舟 Coding Plan": "Volcengine Ark Coding Plan",
   "方舟自动路由（ark-code-latest）": "Ark auto-routing (ark-code-latest)",
   "GLM 最新别名（glm-latest）": "GLM latest alias (glm-latest)",
@@ -37,6 +38,8 @@ export const MODEL_LABELS = {
   // notes
   "控制台管理的动态模型入口；实际使用哪一个模型由 Coding Plan 控制台选择，切换通常数分钟后生效。支持图片理解。":
     "A dynamic model entry managed in the console; which model is actually used is chosen in the Coding Plan console, and a switch usually takes a few minutes. Supports image understanding.",
+  "Agent Plan 自动路由入口；由套餐配置动态选择可用语言模型，支持图片理解。":
+    "Agent Plan auto-routing entry; the plan dynamically selects an available language model. Supports image understanding.",
   [`当前主力。思考默认开启（high），可关闭；支持看图。${FLAT_TAIL}`]: `The current mainstay. Thinking is on by default (high) and can be turned off; supports images. ${FLAT_TAIL_EN}`,
   [`V4-Pro-0813。思考默认开启（high），可关闭；仅文本。${FLAT_TAIL}`]: `V4-Pro-0813. Thinking is on by default (high) and can be turned off; text only. ${FLAT_TAIL_EN}`,
   [`旗舰。思考默认开启，可关闭；支持图片、视频、音频输入。${FLAT_TAIL}`]: `Flagship. Thinking is on by default and can be turned off; accepts image, video and audio input. ${FLAT_TAIL_EN}`,
@@ -87,8 +90,6 @@ export const MODEL_LABELS = {
     "OpenCode Zen · Qwen lightweight multimodal · Anthropic Messages API.",
   "OpenCode Zen · MiniMax 主力模型 · Chat Completions 接口。":
     "OpenCode Zen · MiniMax main model · Chat Completions API.",
-  "OpenCode Zen · 当前限时免费 · Chat Completions 接口。参考 OpenRouter Space Bunny Alpha 规格：1M 上下文、最高 524K 输出，支持图像/视频、推理、工具和 JSON；其匿名第三方提供方可能保留提示和回答。LuckyTri 默认输入 128K、输出 8K、低推理；当前图片链路可用，视频链路未支持。Zen 路由能力与数据政策可能不同。":
-    "OpenCode Zen · free for a limited time · Chat Completions API. Modeled on the OpenRouter Space Bunny Alpha spec: 1M context, up to 524K output, image/video, reasoning, tools and JSON; its anonymous third-party providers may keep prompts and replies. LuckyTri defaults to 128K input, 8K output and low reasoning; images work today, video is not supported. Zen routes may differ in ability and data policy.",
   "OpenAI 兼容接口。上下文先按 128K 填，思考档可按供应商再改。":
     "OpenAI-compatible API. Context is prefilled at 128K; the thinking level can be changed per provider.",
   "已填好 OpenRouter API 地址。请自行填写模型 ID、API Key，并按所选模型设置上下文、输出和能力参数。":
@@ -100,6 +101,14 @@ export const MODEL_PATTERNS = [
     "OpenCode Go · {0} · {1} 接口。默认上下文和输出预算为保守起始值，可按账户实际模型上限调整。",
     "OpenCode Go · {0} · {1} API. Default context and output budgets are conservative starting values; adjust them to your account's real model limits.",
   ],
+  [
+    "Agent Plan 专属 Responses 接口 · 上下文 {0} · LuckyTri 输出预算 {1} · 支持图片理解。默认高强度推理；采样参数由模型服务端处理。",
+    "Agent Plan Responses API · context {0} · LuckyTri output budget {1} · supports image understanding. High reasoning by default; sampling parameters are handled by the model service.",
+  ],
+  [
+    "Agent Plan 专属 Responses 接口 · 上下文 {0} · LuckyTri 输出预算 {1} · 文本模型。默认高强度推理；采样参数由模型服务端处理。",
+    "Agent Plan Responses API · context {0} · LuckyTri output budget {1} · text model. High reasoning by default; sampling parameters are handled by the model service.",
+  ],
   [
     "Coding Plan 专属 Responses 接口 · 上下文 {0} · 官方最大输出 {1} · 支持图片理解。默认中等推理；Kimi K2.8 Preview 在 LuckyTri 中预留 64K 输出预算以保留长上下文。",
     "Coding Plan–only Responses API · context {0} · vendor max output {1} · supports image understanding. Medium reasoning by default; Kimi K2.8 Preview reserves a 64K output budget in LuckyTri to keep the long context.",

package/server/mind/expression-grounding.js

@@ -0,0 +1,24 @@
+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/own-voice.js

@@ -6,6 +6,11 @@ import { isPrivateSession } from "./memory.js";
 import { sameRecentTheme } from "./novelty.js";
 import { ownLife, sameSelf } from "./salience.js";
 import { conversationOrigin, originSummary } from "./conversation-origin.js";
+import {
+  claimsLivedAction,
+  claimsSharedHistory,
+  EXPRESSION_GROUNDING,
+} from "./expression-grounding.js";
 
 // After this many notes in a row that only take up her own last note, another
 // one has to pick up something new or it is not kept.
@@ -203,6 +208,36 @@ export class OwnVoice {
           sources.some((s) => !valid.has(s))
         )
           throw Error("自己的念头含有无效来源或敏感内容，未保存");
+        if (
+          claimsLivedAction([content, ...words].join("\n")) ||
+          claimsSharedHistory([content, result.reason, ...words].join("\n"))
+        ) {
+          const grounded = await models.call(
+            profile,
+            "expression_grounding",
+            EXPRESSION_GROUNDING,
+            {
+              candidate: { note: content, words, sources },
+              actions: input.actions,
+              currentLife: input.currentLife,
+              notes: input.notes,
+              self: input.self,
+            },
+            trace,
+          );
+          if (grounded.ok !== true) {
+            status = "empty";
+            reason =
+              text(grounded.reason, 240) ||
+              "新行动经历没有得到实际记录支持，未保存";
+            return { status, reason, note: null };
+          }
+          if (life.closed || this.mind.nature.version() !== nature.version) {
+            status = "cancelled";
+            reason = "核对期间状态已变化";
+            return { status, reason, note: null };
+          }
+        }
         // Several notes in a row already went round without taking anything
         // new up. Another one that still does not is not kept.
         const drifting =