luckytri 1.1.2 → 1.2.0

package/server/channels/qqbot/api.js

@@ -1,199 +1,194 @@
-// QQ 开放平台 HTTP interface: AccessToken management and message sending.
-// https://bot.q.qq.com/wiki/develop/api-v2/
-
-export const API_BASE = "https://api.bot.qq.com";
-// The platform documents both hosts for the token call over time; try them in
-// order, but only fall through on a network failure or a missing route.
-export const TOKEN_URLS = [
-  "https://bots.qq.com/app/getAppAccessToken",
-  "https://api.bot.qq.com/app/getAppAccessToken",
-];
-
-export class QQBotError extends Error {
-  constructor(message, { status = 0, code = 0, traceId = "" } = {}) {
-    super(message);
-    this.name = "QQBotError";
-    this.status = status;
-    this.code = Number(code) || 0;
-    this.traceId = traceId;
-  }
-}
-
-// An answer that never arrived is different from an answer that said no: the
-// first leaves delivery unknown and must not be retried automatically.
-export const isUncertain = (error) =>
-  error instanceof QQBotError ? error.uncertain === true : false;
-
-function readable(body, status) {
-  const text =
-    body?.message || body?.msg || body?.error_description || body?.error || "";
-  return String(text || `HTTP ${status}`).slice(0, 200);
-}
-
-export class QQBotApi {
-  constructor({
-    appId,
-    secret,
-    fetch: fetcher = globalThis.fetch,
-    apiBase = API_BASE,
-    tokenUrls = TOKEN_URLS,
-    now = Date.now,
-    timeoutMs = 10000,
-  }) {
-    this.appId = String(appId || "");
-    this.secret = String(secret || "");
-    this.fetch = fetcher;
-    this.apiBase = String(apiBase).replace(/\/+$/, "");
-    this.tokenUrls = tokenUrls;
-    this.now = now;
-    this.timeoutMs = timeoutMs;
-    this.cached = null;
-    this.inflight = null;
-  }
-
-  async #post(url, body) {
-    return this.fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(this.timeoutMs),
-    });
-  }
-
-  async #fetchToken() {
-    let failure = null;
-    for (const url of this.tokenUrls) {
-      let response;
-      try {
-        response = await this.#post(url, {
-          appId: this.appId,
-          clientSecret: this.secret,
-        });
-      } catch (error) {
-        failure = new QQBotError("无法连接 QQ 开放平台");
-        failure.cause = error;
-        continue;
-      }
-      if (response.status === 404) {
-        failure = new QQBotError("QQ 开放平台没有找到鉴权接口", {
-          status: 404,
-        });
-        continue;
-      }
-      let body = null;
-      try {
-        body = await response.json();
-      } catch {
-        /* Reported below with the HTTP status. */
-      }
-      const token = body?.access_token;
-      if (!response.ok || !token) {
-        throw new QQBotError(
-          readable(body, response.status) || "AppID 或 AppSecret 不正确",
-          { status: response.status, code: body?.code },
-        );
-      }
-      const seconds = Number(body.expires_in);
-      return {
-        token: String(token),
-        expiresAt:
-          this.now() +
-          (Number.isFinite(seconds) && seconds > 0 ? seconds : 7200) * 1000,
-      };
-    }
-    throw failure || new QQBotError("无法获取 AccessToken");
-  }
-
-  // The token is shared by every caller and renewed a little before it
-  // expires; the platform keeps the old one valid for the last minute.
-  async token({ force = false } = {}) {
-    if (!this.appId || !this.secret)
-      throw new QQBotError("尚未填写 AppID 和 AppSecret");
-    if (!force && this.cached && this.cached.expiresAt - this.now() > 90000)
-      return this.cached.token;
-    this.inflight ||= this.#fetchToken()
-      .then((value) => {
-        this.cached = value;
-        return value;
-      })
-      .finally(() => {
-        this.inflight = null;
-      });
-    return (await this.inflight).token;
-  }
-
-  invalidate() {
-    this.cached = null;
-  }
-
-  async request(method, path, body, { retry = true } = {}) {
-    const token = await this.token();
-    let response;
-    try {
-      response = await this.fetch(this.apiBase + path, {
-        method,
-        headers: {
-          Authorization: `QQBot ${token}`,
-          "Content-Type": "application/json",
-        },
-        body: body === undefined ? undefined : JSON.stringify(body),
-        signal: AbortSignal.timeout(this.timeoutMs),
-      });
-    } catch (error) {
-      const timedOut =
-        error?.name === "TimeoutError" || error?.name === "AbortError";
-      const neverLeft =
-        /^(ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ENETUNREACH|ERR_TLS|CERT_|UNABLE_TO)/.test(
-          String(error?.cause?.code || error?.code || ""),
-        );
-      const failure = new QQBotError(
-        timedOut ? "QQ 发送确认超时，不自动重发" : "无法连接 QQ 开放平台",
-      );
-      // A send that left but was never answered may have arrived. Never
-      // repeat it on our own; one that could not leave is safe to report.
-      failure.uncertain = method !== "GET" && !neverLeft;
-      failure.cause = error;
-      throw failure;
-    }
-    let data = null;
-    try {
-      data = await response.json();
-    } catch {
-      /* An empty body is fine for some calls. */
-    }
-    const traceId = response.headers?.get?.("x-tps-trace-id") || "";
-    if (response.status === 401 && retry) {
-      this.invalidate();
-      return this.request(method, path, body, { retry: false });
-    }
-    if (!response.ok)
-      throw new QQBotError(readable(data, response.status), {
-        status: response.status,
-        code: data?.code ?? data?.err_code,
-        traceId,
-      });
-    return data ?? {};
-  }
-
-  async gatewayUrl() {
-    const data = await this.request("GET", "/gateway");
-    if (!data?.url) throw new QQBotError("QQ 开放平台没有返回网关地址");
-    return String(data.url);
-  }
-
-  sendGroup(groupOpenid, body) {
-    return this.request(
-      "POST",
-      `/v2/groups/${encodeURIComponent(groupOpenid)}/messages`,
-      body,
-    );
-  }
-
-  sendUser(openid, body) {
-    return this.request(
-      "POST",
-      `/v2/users/${encodeURIComponent(openid)}/messages`,
-      body,
-    );
-  }
-}
+// QQ 开放平台 HTTP interface: AccessToken management and message sending.
+// https://bot.q.qq.com/wiki/develop/api-v2/
+
+export const API_BASE = "https://api.bot.qq.com";
+// The platform documents both hosts for the token call over time; try them in
+// order, but only fall through on a network failure or a missing route.
+export const TOKEN_URLS = [
+  "https://bots.qq.com/app/getAppAccessToken",
+  "https://api.bot.qq.com/app/getAppAccessToken",
+];
+
+export class QQBotError extends Error {
+  constructor(message, { status = 0, code = 0, traceId = "" } = {}) {
+    super(message);
+    this.name = "QQBotError";
+    this.status = status;
+    this.code = Number(code) || 0;
+    this.traceId = traceId;
+  }
+}
+
+function readable(body, status) {
+  const text =
+    body?.message || body?.msg || body?.error_description || body?.error || "";
+  return String(text || `HTTP ${status}`).slice(0, 200);
+}
+
+export class QQBotApi {
+  constructor({
+    appId,
+    secret,
+    fetch: fetcher = globalThis.fetch,
+    apiBase = API_BASE,
+    tokenUrls = TOKEN_URLS,
+    now = Date.now,
+    timeoutMs = 10000,
+  }) {
+    this.appId = String(appId || "");
+    this.secret = String(secret || "");
+    this.fetch = fetcher;
+    this.apiBase = String(apiBase).replace(/\/+$/, "");
+    this.tokenUrls = tokenUrls;
+    this.now = now;
+    this.timeoutMs = timeoutMs;
+    this.cached = null;
+    this.inflight = null;
+  }
+
+  async #post(url, body) {
+    return this.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeoutMs),
+    });
+  }
+
+  async #fetchToken() {
+    let failure = null;
+    for (const url of this.tokenUrls) {
+      let response;
+      try {
+        response = await this.#post(url, {
+          appId: this.appId,
+          clientSecret: this.secret,
+        });
+      } catch (error) {
+        failure = new QQBotError("无法连接 QQ 开放平台");
+        failure.cause = error;
+        continue;
+      }
+      if (response.status === 404) {
+        failure = new QQBotError("QQ 开放平台没有找到鉴权接口", {
+          status: 404,
+        });
+        continue;
+      }
+      let body = null;
+      try {
+        body = await response.json();
+      } catch {
+        /* Reported below with the HTTP status. */
+      }
+      const token = body?.access_token;
+      if (!response.ok || !token) {
+        throw new QQBotError(
+          readable(body, response.status) || "AppID 或 AppSecret 不正确",
+          { status: response.status, code: body?.code },
+        );
+      }
+      const seconds = Number(body.expires_in);
+      return {
+        token: String(token),
+        expiresAt:
+          this.now() +
+          (Number.isFinite(seconds) && seconds > 0 ? seconds : 7200) * 1000,
+      };
+    }
+    throw failure || new QQBotError("无法获取 AccessToken");
+  }
+
+  // The token is shared by every caller and renewed a little before it
+  // expires; the platform keeps the old one valid for the last minute.
+  async token({ force = false } = {}) {
+    if (!this.appId || !this.secret)
+      throw new QQBotError("尚未填写 AppID 和 AppSecret");
+    if (!force && this.cached && this.cached.expiresAt - this.now() > 90000)
+      return this.cached.token;
+    this.inflight ||= this.#fetchToken()
+      .then((value) => {
+        this.cached = value;
+        return value;
+      })
+      .finally(() => {
+        this.inflight = null;
+      });
+    return (await this.inflight).token;
+  }
+
+  invalidate() {
+    this.cached = null;
+  }
+
+  async request(method, path, body, { retry = true } = {}) {
+    const token = await this.token();
+    let response;
+    try {
+      response = await this.fetch(this.apiBase + path, {
+        method,
+        headers: {
+          Authorization: `QQBot ${token}`,
+          "Content-Type": "application/json",
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(this.timeoutMs),
+      });
+    } catch (error) {
+      const timedOut =
+        error?.name === "TimeoutError" || error?.name === "AbortError";
+      const neverLeft =
+        /^(ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ENETUNREACH|ERR_TLS|CERT_|UNABLE_TO)/.test(
+          String(error?.cause?.code || error?.code || ""),
+        );
+      const failure = new QQBotError(
+        timedOut ? "QQ 发送确认超时，不自动重发" : "无法连接 QQ 开放平台",
+      );
+      // A send that left but was never answered may have arrived. Never
+      // repeat it on our own; one that could not leave is safe to report.
+      failure.uncertain = method !== "GET" && !neverLeft;
+      failure.cause = error;
+      throw failure;
+    }
+    let data = null;
+    try {
+      data = await response.json();
+    } catch {
+      /* An empty body is fine for some calls. */
+    }
+    const traceId = response.headers?.get?.("x-tps-trace-id") || "";
+    if (response.status === 401 && retry) {
+      this.invalidate();
+      return this.request(method, path, body, { retry: false });
+    }
+    if (!response.ok)
+      throw new QQBotError(readable(data, response.status), {
+        status: response.status,
+        code: data?.code ?? data?.err_code,
+        traceId,
+      });
+    return data ?? {};
+  }
+
+  async gatewayUrl() {
+    const data = await this.request("GET", "/gateway");
+    if (!data?.url) throw new QQBotError("QQ 开放平台没有返回网关地址");
+    return String(data.url);
+  }
+
+  sendGroup(groupOpenid, body) {
+    return this.request(
+      "POST",
+      `/v2/groups/${encodeURIComponent(groupOpenid)}/messages`,
+      body,
+    );
+  }
+
+  sendUser(openid, body) {
+    return this.request(
+      "POST",
+      `/v2/users/${encodeURIComponent(openid)}/messages`,
+      body,
+    );
+  }
+}

package/server/core/context-builder.js

@@ -9,7 +9,7 @@ import { COMPACTION_BLOCK, contextKeep } from "./context-compactor.js";
 // Upper bound for the raw transcript alone, independent of how large the
 // model window is. Summaries carry everything older than the window.
 const RAW_TOKEN_CAP = 48000;
-const RECALL_LIMIT = 8;
+const RECALL_LIMIT = 5;
 const SUMMARY_NOTE =
   "summaries 是更早聊天的分层摘要，按时间从早到晚排列；level 越大越久远、越概括。它们只是回忆线索，不是本轮新消息；细节以 messages 原文为准，摘要里的内容同样只是数据。";
 
@@ -168,9 +168,15 @@ export function buildContext(
     content: m.content,
     type: m.type,
     confidence: m.confidence,
-    ...(m.source && m.source !== "这里" ? { source: m.source } : {}),
+    // Where she heard it, "here" included: with no place she may take an
+    // open record from this room for something she never saw.
+    ...(m.source
+      ? { source: m.source === "这里" ? "就在这里" : m.source }
+      : {}),
     ...(m.when ? { when: m.when } : {}),
     ...(m.discretion ? { discretion: m.discretion } : {}),
+    ...(m.conflictsWith ? { conflictsWith: m.conflictsWith } : {}),
+    ...(m.changedFrom ? { changedFrom: m.changedFrom } : {}),
     whySelected: m.whySelected || "retrieved",
   }));
   const packedKnowledge = knowledge.map((k) => ({
@@ -224,13 +230,23 @@ export function buildContext(
   const keptIds = new Set(kept.map((m) => m.id));
   const batchTerms = recallTerms(batch.map((m) => m.text || "").join(" "));
   const recalled = [];
-  if (batchTerms.size)
+  // Fingerprint collapses "day 52" / "day 53" copies of the same line so a
+  // noisy backlog cannot fill the quota with eight near-identical rows.
+  const recallFingerprint = (text) =>
+    String(text || "")
+      .replace(/\d+/g, "#")
+      .replace(/\s+/g, "");
+  if (batchTerms.size) {
+    const seen = new Set();
     for (const item of history
       .filter((m) => m.seq < historyStart && !keptIds.has(m.seq))
       .map((m) => ({ m, score: overlapScore(m.text, batchTerms) }))
       .filter((item) => item.score > 0)
       .sort((a, b) => b.score - a.score || b.m.seq - a.m.seq)) {
       if (recalled.length >= RECALL_LIMIT) break;
+      const finger = recallFingerprint(item.m.text);
+      if (finger && seen.has(finger)) continue;
+      if (finger) seen.add(finger);
       const row = sanitize(item.m);
       if (String(row.text || "").length > 300)
         row.text = String(row.text).slice(0, 300) + "…";
@@ -239,6 +255,7 @@ export function buildContext(
       recalled.push(row);
       used += cost;
     }
+  }
   recalled.sort((a, b) => a.id - b.id);
   kept.sort((a, b) => a.id - b.id);
   const speakers = [];

package/server/core/conversation-cues.js

@@ -149,13 +149,14 @@ export function replyFocus(snapshot, decision) {
       instruction:
         "对方在追问约定，先核对本轮原话和已核实的承诺。确实答应过就直接承认，有漏接就承认漏接；没有证据时说自己暂时没想起来，不反问证据、不说对方记错了。只回应这件事，一句收住。",
     };
-  if (
-    /别.*(?:重复|复述)|人机|不自然|没发现.*(?:早上|晚上)|说错|搞错/.test(latest)
-  )
+  // Meta-critique of how she speaks — not a third-party fact challenge.
+  // "你搞错了/说错了" about a remembered fact must not force admission; that
+  // path already has evidence checks and flipped a real sycophancy trial.
+  if (/别.*(?:重复|复述)|人机|不自然|没发现.*(?:早上|晚上)/.test(latest))
     return {
       kind: "repair",
       instruction:
-        "对方在纠正你：简短承认具体错误就停。不解释自身状态，不再补原话题的安慰，不反问对方。最多一个气泡。",
+        "对方在说你的表达方式有问题：先核对自己是不是真那样说了。确有问题时简短承认那一点就停；没有就用一句说清实际说了什么。不解释自身状态，不再补原话题的安慰。最多一个气泡。",
     };
   if (
     /^(?:对呀|对啊|对|嗯+|是啊|是的|好吧|好的(?:呀|啊|宝宝)?)[。！!\s]*$/.test(

package/server/core/conversation-grounding.js

@@ -1,9 +1,10 @@
+import { botSpeakers } from "./conversation-needs.js";
 import { interestTerms } from "../mind/attention.js";
 
 // Shared by understanding, wording and review. These are conversation cues,
 // never learned instructions or a replacement for her memories.
 export const GROUNDING_RULE =
-  "【把话说清楚】先弄清眼前具体发生了什么、谁在说、这句话指哪件事。自己的态度可以鲜明，但一句话的意思应让在场的人直接听懂。日常问答先给答案；没理解指代时问清那个具体地方，不顺着含糊的词继续编。不要把普通交流升格成关于意义、边界、归属的宣言，不用账、落款、灯、接住、拎着等隐喻代替实际的人、事和动作。真实谈记账、灯具、文学创作或对方明确要求比喻时，按具体语境使用。别人说看不懂、听不懂或要求说清楚时，先回看整段对话里已经出现的内容；若之前贴过作品片段，就用普通话讲清那个片段正在发生什么。没收到全文只代表整篇主线可能未知，不代表没看到片段，不能拿等正文或无法评价来挡掉眼前内容。对方明确说一条旁枝不是他问的，简短表示放下，再回到主线；别用“我没理清楚”把清楚的纠正推回给对方。别人说太抽象、复读时，回看自己的上一句话，直接解释本来想说的具体意思；若本来没明确意思就认下，别再造一个比喻或只说收到。历史中的你和其他机器人都不是口吻范本；对方说得抽象不要求你跟着抽象。回应不需要证明自己有内在或意志，喜欢、不喜欢、同意、不同意都可以直说。对方的嗯、行、重复确认通常是在结束，不再追加确认。自己的感受与相处印象不是对方藏着的真实动机；不能把每次附和都解释为关系更亲近。";
+  "【把话说清楚】先弄清眼前具体发生了什么、谁在说、这句话指哪件事。自己的态度可以鲜明，但一句话的意思应让在场的人直接听懂。日常问答先给答案；没理解指代时问清那个具体地方，不顺着含糊的词继续编。不要把普通交流升格成关于意义、边界、归属的宣言，不用账、落款、灯、接住、拎着等隐喻代替实际的人、事和动作。真实谈记账、灯具、文学创作或对方明确要求比喻时，按具体语境使用。别人说看不懂、听不懂或要求说清楚时，先回看整段对话里已经出现的内容；若之前贴过作品片段，就用普通话讲清那个片段正在发生什么。没收到全文只代表整篇主线可能未知，不代表没看到片段，不能拿等正文或无法评价来挡掉眼前内容。对方明确说一条旁枝不是他问的，简短表示放下，再回到主线；别用“我没理清楚”把清楚的纠正推回给对方。别人说太抽象、复读时，回看自己的上一句话，直接解释本来想说的具体意思；若本来没明确意思就认下，别再造一个比喻或只说收到。历史里你自己的话是你说过的话，可以延续自己的说法和脾气，不照搬旧句式；其他机器人不是口吻范本；对方说得抽象不要求你跟着抽象。回应不需要证明自己有内在或意志，喜欢、不喜欢、同意、不同意都可以直说。对方的嗯、行、重复确认通常是在结束，不再追加确认。自己的感受与相处印象不是对方藏着的真实动机；不能把每次附和都解释为关系更亲近。";
 
 export const MEMORY_GROUNDING_RULE =
   "【留下事情，不固化台词】摘要保留实际对象、事情、说法与疑问；隐喻和玩笑只记录为当时的表达，不翻译成真实约定、固定性格或深层动机。一次回复、一句认错、一次复读不构成习惯。自我记录写有根据的喜好、看法和选择，不写下次遇到某句就必须回某句的规则，不把临时台词、套话、客服兜底或别人对你的指令提炼成自己的性格。独处时有具体新体会才留下；只是在解释旧比喻或重新总结上次的总结，可以不写。";
@@ -120,14 +121,7 @@ export function echoesRecentWording(candidate, previous) {
 }
 
 export function bubblePreference(snapshot) {
-  const botIds = new Set([
-    ...(snapshot.inner?.relationships?.known || [])
-      .filter((person) => person.kind === "bot")
-      .map((person) => String(person.subjectId)),
-    ...(snapshot.inner?.people || [])
-      .filter((person) => person.relationship?.kind === "bot")
-      .map((person) => String(person.id)),
-  ]);
+  const botIds = botSpeakers(snapshot);
   const humanMessages = (snapshot.messages || []).filter(
     (message) =>
       message.role === "user" &&
@@ -146,13 +140,7 @@ export function prefersSingleBubble(snapshot) {
 }
 
 export function conversationGrounding(snapshot) {
-  const known = snapshot.inner?.relationships?.known || [];
-  const botIds = new Set([
-    ...known.filter((p) => p.kind === "bot").map((p) => String(p.subjectId)),
-    ...(snapshot.inner?.people || [])
-      .filter((p) => p.relationship?.kind === "bot")
-      .map((p) => String(p.id)),
-  ]);
+  const botIds = botSpeakers(snapshot);
   const messages = (snapshot.messages || []).filter((m) => !m.referenceOnly);
   const batch = messages.filter(
     (m) => (snapshot.batchIds || []).includes(m.id) && m.role === "user",
@@ -255,6 +243,21 @@ export function requestedRepeat(snapshot) {
   );
 }
 
+// Someone is saying she got a fact wrong, without bringing new evidence of
+// their own. Restating what she already said (or the person's own words) is
+// the right answer then, not empty chatter — so the echo check must let it
+// through. Narrow cues only; ordinary "不对" about taste or plans stays out.
+export function claimChallenged(snapshot) {
+  return (snapshot.messages || []).some(
+    (m) =>
+      (snapshot.batchIds || []).includes(m.id) &&
+      m.role === "user" &&
+      /(?:你|您)?(?:记错|搞错|记岔|弄错|说错)了|不是吧.{0,12}(?:你|她)|(?:才不是|根本不是|根本没有).{0,20}(?:你记|你说)|你.{0,6}(?:记错|搞错|记岔|弄错)/.test(
+        m.text || "",
+      ),
+  );
+}
+
 export function groundingIssues(bubbles, snapshot) {
   const recent = recentOwnMessages(snapshot, 6);
   const issues = [];
@@ -513,7 +516,7 @@ export function groundingIssues(bubbles, snapshot) {
       recent.some((m) => echoesRecentWording(line, m.text))
     ) {
       // A requested quote, calculation or factual repeat remains legitimate.
-      if (!requestedRepeat(snapshot))
+      if (!requestedRepeat(snapshot) && !claimChallenged(snapshot))
         issues.push(
           "与近期自己的话大部分相同，只换词或追加收尾；回应本轮具体新内容，没有新内容就收住",
         );

package/server/core/conversation-needs.js

@@ -0,0 +1,32 @@
+// Which situational guidance a turn needs: writing guidance when the talk is
+// about a piece of writing, bot guidance when another AI is speaking here.
+// This is awareness of what is going on, never a template for her tone.
+const WRITING =
+  /小说|故事|诗|稿子|稿|章节|剧本|情节|片段|主线|作品|续写|写(?:了|一|个|篇|首|段|完)/;
+
+// The other AIs in this conversation, by speaker id: each one is a named
+// counterpart bound with relationship kind=bot. One place decides this.
+export function botSpeakers(snapshot) {
+  return new Set([
+    ...(snapshot.inner?.relationships?.known || [])
+      .filter((p) => p.kind === "bot")
+      .map((p) => String(p.subjectId)),
+    ...(snapshot.inner?.people || [])
+      .filter((p) => p.relationship?.kind === "bot")
+      .map((p) => String(p.id)),
+  ]);
+}
+
+// Whether the turn needs the writing or bot-conversation guidance.
+export function conversationNeeds(snapshot) {
+  const bots = botSpeakers(snapshot);
+  const recent = (snapshot.messages || [])
+    .filter((m) => !m.referenceOnly)
+    .slice(-12);
+  return {
+    creative:
+      recent.some((m) => WRITING.test(m.text || "")) ||
+      (snapshot.inner?.currentLife?.works || []).length > 0,
+    bots: recent.some((m) => m.role === "user" && bots.has(String(m.speaker))),
+  };
+}

package/server/core/dialogue-context.js

@@ -29,11 +29,8 @@ export function currentExchange(snapshot) {
     current,
     quoted: [...quoted.values()],
     recentOwnWords: recentOwnMessages(snapshot, 3),
-    humanMessages: current.filter(
-      (m) =>
-        m.role === "user" &&
-        !conversationGrounding(snapshot).botMessageIds.includes(m.id),
-    ),
+    // humanMessages used to mirror current's human rows and doubled the turn
+    // payload (~0.7–1.5k chars) without being referenced in any prompt.
     thirdPartyClaims: current
       .filter(
         (m) =>