luckytri 1.0.8 → 1.1.0

package/server/core/turn.js

@@ -1,15 +1,39 @@
 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",
+];
+export const TONES = ["serious", "joking", "teasing", "ironic", "venting"];
+export const STANCES = ["fact", "guess", "opinion", "joke", "hearsay"];
 const LEGACY = {
   REPLY: "speak",
   MULTI_MESSAGE: "speak",
@@ -17,8 +41,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 +111,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 +131,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) =>
@@ -128,11 +311,44 @@ const ids = (value) =>
     .map((id) => (typeof id === "string" && /^\d+$/.test(id) ? Number(id) : id))
     .filter((id) => Number.isSafeInteger(id));
 
+// A model sometimes closes an object too early or too late, leaving a
+// top-level field inside understanding or contribution, or the reading
+// fields outside. Put them back where the contract says they belong.
+function liftMisplaced(raw, trace) {
+  const out = { ...raw };
+  let moved = false;
+  for (const key of ["understanding", "contribution"]) {
+    const inner = out[key];
+    if (!inner || typeof inner !== "object" || Array.isArray(inner)) continue;
+    for (const field of [
+      "choice",
+      "targetMessageIds",
+      "topic",
+      "bubbles",
+      "appraisal",
+      "reason",
+    ])
+      if (out[field] === undefined && inner[field] !== undefined) {
+        out[field] = inner[field];
+        moved = true;
+      }
+  }
+  if (out.understanding && typeof out.understanding === "object")
+    for (const field of ["tone", "stance"])
+      if (out[field] !== undefined && out.understanding[field] === undefined) {
+        out.understanding = { ...out.understanding, [field]: out[field] };
+        moved = true;
+      }
+  if (moved) trace?.steps?.push("回合输出有字段放错了层级，已按约定归位");
+  return out;
+}
+
 export function normalizeTurn(raw, snapshot, trace) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw))
     throw SyntaxError("回合输出不是 JSON 对象");
   const known = new Set((snapshot.messages || []).map((m) => m.id));
   const batchIds = new Set(snapshot.batchIds || []);
+  raw = liftMisplaced(raw, trace);
   let choice = CHOICES.includes(raw.choice)
     ? raw.choice
     : LEGACY[raw.action] || null;
@@ -149,7 +365,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 +393,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 +423,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 +441,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 +464,7 @@ export function normalizeTurn(raw, snapshot, trace) {
   return {
     choice,
     share:
-      !botLoop &&
+      !botYield &&
       !stopped &&
       raw.share &&
       ["send", "later", "decline"].includes(raw.share.choice)
@@ -233,7 +475,7 @@ export function normalizeTurn(raw, snapshot, trace) {
           }
         : null,
     attention:
-      !botLoop &&
+      !botYield &&
       raw.attention &&
       ["continue", "chat", "rest"].includes(raw.attention.action)
         ? {
@@ -241,20 +483,33 @@ 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),
             ),
             point: text(raw.understanding.point, 180),
+            ...(TONES.includes(raw.understanding.tone)
+              ? { tone: raw.understanding.tone }
+              : {}),
+            ...(STANCES.includes(raw.understanding.stance)
+              ? { stance: raw.understanding.stance }
+              : {}),
           },
         }
       : {}),
@@ -275,17 +530,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/core/understanding.js

@@ -0,0 +1,85 @@
+// Cheap readings of the batch that a model would otherwise have to work out
+// from scratch: one person's run of messages read as one utterance, and
+// surface signs of tone and certainty. They are hints with their reason, not
+// verdicts; the turn decides what was meant.
+const LAUGH =
+  /哈{3,}|h{3,}|233+|笑死|绷不住|乐死|xswl|\[doge\]|（狗头）|\(狗头\)|🐶|😂|🤣/i;
+const TEASE = /开玩笑|逗你|骗你的|假的啦|就随便说说|嘴硬|你行你上|鉴定为/;
+const IRONY =
+  /呵呵|真行|可真(?:行|会|厉害)|好家伙|太(?:厉害|聪明)了吧|厉害了我的|谢谢你啊|那可太|笑死个人|真是谢谢/;
+const GUESS = /可能|应该是|估计|大概|好像|也许|说不定|我猜|不确定|感觉是|似乎/;
+const OPINION = /我觉得|我认为|我感觉|在我看来|个人觉得|我更喜欢|还是.{0,6}好/;
+const HEARSAY = /听说|据说|他说|她说|有人说|别人说|朋友说/;
+const COMPLAIN = /烦死|好烦|气死|无语|崩溃|受不了|服了|累死|心累|难受/;
+
+export function messageCues(text) {
+  const value = String(text || "");
+  const tone = [];
+  if (LAUGH.test(value)) tone.push("laughing");
+  if (TEASE.test(value)) tone.push("teasing");
+  if (IRONY.test(value)) tone.push("maybe_ironic");
+  if (COMPLAIN.test(value)) tone.push("complaining");
+  const stance = HEARSAY.test(value)
+    ? "hearsay"
+    : GUESS.test(value)
+      ? "guess"
+      : OPINION.test(value)
+        ? "opinion"
+        : null;
+  return { tone, stance };
+}
+
+// Consecutive messages from one person in the batch, read as one turn of
+// speech: "我明天" + "要去面试" + "好紧张" is one sentence typed in pieces.
+export function utterances(messages = [], batchIds = []) {
+  const fresh = new Set(batchIds);
+  const rows = messages
+    .filter((m) => fresh.has(m.id) && m.role === "user")
+    .sort((a, b) => a.id - b.id);
+  const groups = [];
+  for (const m of rows) {
+    const last = groups.at(-1);
+    if (
+      last &&
+      last.speaker === String(m.speaker) &&
+      m.time - last.until < 90000
+    ) {
+      last.ids.push(m.id);
+      last.text += ` ${m.text || ""}`;
+      last.until = m.time;
+    } else
+      groups.push({
+        speaker: String(m.speaker),
+        name: m.name,
+        ids: [m.id],
+        text: m.text || "",
+        until: m.time,
+      });
+  }
+  return groups
+    .filter((g) => g.ids.length > 1)
+    .map(({ until: _until, ...g }) => ({
+      ...g,
+      text: g.text.trim().slice(0, 160),
+    }));
+}
+
+export function understandingHints(messages = [], batchIds = []) {
+  const fresh = new Set(batchIds);
+  const cues = messages
+    .filter((m) => fresh.has(m.id) && m.role === "user")
+    .map((m) => ({ messageId: m.id, ...messageCues(m.text) }))
+    .filter((c) => c.tone.length || c.stance)
+    .map((c) => ({
+      messageId: c.messageId,
+      ...(c.tone.length ? { tone: c.tone } : {}),
+      ...(c.stance ? { stance: c.stance } : {}),
+    }));
+  const groups = utterances(messages, batchIds);
+  if (!cues.length && !groups.length) return null;
+  return {
+    ...(groups.length ? { utterances: groups } : {}),
+    ...(cues.length ? { surfaceCues: cues } : {}),
+    note: "从字面看出的语气与把握程度提示，不是结论：反讽、玩笑要结合前后文判断；连续几条是同一个人分开打的一句话。",
+  };
+}