luckytri 1.0.8 → 1.0.9

package/server/core/turn.js

@@ -1,15 +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 {
+  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",
@@ -17,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}$/;
@@ -73,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,
@@ -92,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)
-        : 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) } : {}),
-    },
+      : 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) =>
@@ -149,7 +330,11 @@ export function normalizeTurn(raw, snapshot, trace) {
   }
   if (
     choice === "react" &&
-    readerQuestions(snapshot, { choice }).some((q) => targets.includes(q.id))
+    readerQuestions(snapshot, {
+      choice,
+      targetMessageIds: targets,
+      understanding: raw.understanding,
+    }).some((q) => targets.includes(q.id))
   ) {
     choice = "speak";
     trace?.steps?.push("对方在要求解释，保留完整回答空间，不按极短反应截断");
@@ -173,6 +358,20 @@ export function normalizeTurn(raw, snapshot, trace) {
       "这是一句完整回应，按正常发言保留，不为短反应标签改写原意",
     );
   }
+  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),
@@ -189,10 +388,13 @@ 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 ||
+    (grounding.botLoop ||
       (raw.contribution?.kind === "none" &&
         !raw.act &&
         !raw.share &&
@@ -204,10 +406,15 @@ export function normalizeTurn(raw, snapshot, trace) {
           .every((m) =>
             conversationGrounding(snapshot).botMessageIds.includes(m.id),
           )));
-  if (botLoop) {
+  const botYield = botLoop || botFollowupLimit;
+  if (botYield) {
     choice = "silent";
     bubbles = [];
-    trace?.steps?.push("机器人连续确认没有新内容，这段对话在此收住");
+    trace?.steps?.push(
+      botFollowupLimit
+        ? "机器人之间已经连续说过两轮，这次没有新的直接提问或纠正，先留出空间"
+        : "机器人连续确认没有新内容，这段对话在此收住",
+    );
   }
   const stopped = !crisis && explicitStop(snapshot);
   if (stopped) {
@@ -222,7 +429,7 @@ export function normalizeTurn(raw, snapshot, trace) {
   return {
     choice,
     share:
-      !botLoop &&
+      !botYield &&
       !stopped &&
       raw.share &&
       ["send", "later", "decline"].includes(raw.share.choice)
@@ -233,7 +440,7 @@ export function normalizeTurn(raw, snapshot, trace) {
           }
         : null,
     attention:
-      !botLoop &&
+      !botYield &&
       raw.attention &&
       ["continue", "chat", "rest"].includes(raw.attention.action)
         ? {
@@ -241,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),
             ),
@@ -275,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",
   "写回顾期间关系记录已变化，本次旧稿未保存，下次按新认识整理":

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

@@ -4,9 +4,12 @@ export function claimsLivedAction(content) {
     .some(
       (clause) =>
         !/想|打算|准备|希望|假如|设想|如果/.test(clause) &&
-        /(?:刚才|刚刚|今天|这次|然后|真的|已经)[^。！？]{0,25}(?:读了|读上|读完|翻开|翻出来|写完|完成了|打开了|开始读|动手了)/.test(
+        (/(?:刚才|刚刚|今天|这次|然后|真的|已经)[^。！？]{0,25}(?:读了|读上|读完|读[一二两三几\d]+[段页章节遍]|坐下来读|翻开|翻出来|写完|完成了|打开了|开始读|动手了)/.test(
           clause,
-        ),
+        ) ||
+          /我(?:自己)?[^。！？]{0,10}(?:读上了|开始读了|翻开了|完成了|写完了)/.test(
+            clause,
+          )),
     );
 }
 

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

@@ -0,0 +1,65 @@
+const OWN_REFERENCE =
+  /你.{0,16}(?:不是说|明明说|说过|提过|答应过)|你跟.{0,16}(?:说|提过|答应过)|(?:上次|之前|刚才|昨天).{0,18}(?:你|我).{0,10}(?:说|提|答应)/;
+
+// A same-person follow-up may point to what she just said without repeating
+// a work's title. Use only replies actually addressed to this speaker as extra
+// search terms; the private reply itself never enters the memory result.
+export function activityRecallCue(
+  batch = [],
+  messages = [],
+  { excludedSpeakers = new Set() } = {},
+) {
+  const current = batch.filter(
+    (message) =>
+      message.role === "user" &&
+      !excludedSpeakers.has(String(message.speaker ?? message.userId ?? "")) &&
+      OWN_REFERENCE.test(message.text || ""),
+  );
+  if (!current.length) return batch;
+
+  const speakers = new Set(
+    current
+      .map((message) => String(message.speaker ?? message.userId ?? ""))
+      .filter(Boolean),
+  );
+  if (!speakers.size) return batch;
+  const byId = new Map(
+    messages.map((message) => [Number(message.seq ?? message.id), message]),
+  );
+  const cutoff = Math.min(
+    ...batch
+      .map((message) => Number(message.id ?? message.seq))
+      .filter(Number.isFinite),
+  );
+  const now = Math.max(
+    ...batch.map((message) => Number(message.time)).filter(Number.isFinite),
+  );
+  const replies = messages.filter((message) => {
+    if (message.role !== "assistant" || message.referenceOnly) return false;
+    if (Number.isFinite(message.id ?? message.seq) && Number.isFinite(cutoff)) {
+      const id = Number(message.id ?? message.seq);
+      if (
+        id >= cutoff &&
+        (!Number.isFinite(message.time) || message.time > now)
+      )
+        return false;
+    }
+    const targets = [
+      ...(Array.isArray(message.replyTargets) ? message.replyTargets : []),
+      ...(Array.isArray(message.replyTargetIds)
+        ? message.replyTargetIds.map((id) => byId.get(Number(id)))
+        : []),
+    ];
+    return targets.some((target) =>
+      speakers.has(String(target?.speaker ?? target?.userId ?? "")),
+    );
+  });
+  return [
+    ...batch,
+    ...replies.slice(-2).map((message) => ({
+      role: "assistant",
+      activityEvidence: true,
+      text: message.text || "",
+    })),
+  ];
+}

package/server/mind/time/index.js

@@ -422,7 +422,7 @@ export class TimeSystem {
       }),
     };
   }
-  view({ session, now = this.now(), cue = [] } = {}) {
+  view({ session, now = this.now(), cue = [], activityCue = cue } = {}) {
     const primary = this.primary(),
       task = primary?.created <= now ? primary : null;
     let current =
@@ -548,7 +548,11 @@ export class TimeSystem {
           plannedFor: this.planView(row),
         })),
       works: this.works.fragments({ session, now, cue }),
-      activityRecall: this.works.activityEvidence({ session, now, cue }),
+      activityRecall: this.works.activityEvidence({
+        session,
+        now,
+        cue: activityCue,
+      }),
       ...(() => {
         const actions = this.db
           .prepare(

package/server/mind/time/tasks.js

@@ -212,16 +212,14 @@ export class Tasks {
       now,
     );
     if (type === "read" && awaitsTextInput(title)) {
-      this.db
-        .prepare("UPDATE mind_time_tasks SET checkpoint=? WHERE id=?")
-        .run(
-          JSON.stringify({
-            awaitedText: true,
-            expectedTextTitle: intent.topic,
-            awaitedAfter: now,
-          }),
-          id,
-        );
+      this.db.prepare("UPDATE mind_time_tasks SET checkpoint=? WHERE id=?").run(
+        JSON.stringify({
+          awaitedText: true,
+          expectedTextTitle: intent.topic,
+          awaitedAfter: now,
+        }),
+        id,
+      );
       this.wait(
         this.get(id),
         "等待约定的正文或资料",

package/server/mind/time/works.js

@@ -464,7 +464,7 @@ export class Works {
       (Array.isArray(cue) ? cue : [cue]).map((v) =>
         typeof v === "string"
           ? v
-          : v?.role === "assistant"
+          : v?.role === "assistant" && !v.activityEvidence
             ? ""
             : v?.text || "",
       ),
@@ -472,7 +472,8 @@ export class Works {
     if (!terms.size) return [];
     // A private conversation can motivate her own reading. Its contents and
     // promises stay private; absence from the public fragments must not erase
-    // the fact that the explicitly named reading activity took place.
+    // the fact that the reading took place. Search may also use a same-speaker
+    // reply delivered in this room to resolve an implicit follow-up.
     return this.db
       .prepare(
         `SELECT w.id,w.title,w.discretion,w.session_id,p.kind,p.title project_title,p.bible,v.created,v.provenance,v.sources

package/server/mind/view.js

@@ -95,7 +95,14 @@ function feedback(mind, session, now) {
 // so anything this batch of messages brings back to mind belongs there.
 export function innerView(
   mind,
-  { session, kind = "group", people = [], cue = [], now = Date.now() },
+  {
+    session,
+    kind = "group",
+    people = [],
+    cue = [],
+    activityCue = cue,
+    now = Date.now(),
+  },
 ) {
   const nature = mind.nature.current(now);
   const affect = mind.affect.state(now, { nature, room: session });
@@ -300,7 +307,7 @@ export function innerView(
     self,
     affect: cause ? affect : { ...affect, cause: "" },
     inner: {
-      currentLife: mind.time.view({ session, now, cue }),
+      currentLife: mind.time.view({ session, now, cue, activityCue }),
       state: `${affect.phaseLabel}，精力${affect.energyLabel}，心情${affect.mood}${cause ? `（${cause}）` : ""}${affect.lately ? `，${affect.lately}` : ""}`,
       ...(persons.length ? { people: persons } : {}),
       ...(relationships.known.length ? { relationships } : {}),