koishi-plugin-satori-ai 2.0.0 → 2.0.1

package/lib/index.js

@@ -170,6 +170,10 @@ __name(extendDatabase, "extendDatabase");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var logger = new import_koishi.Logger("satori-utils");
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
 function parseTimeToMinutes(timeStr) {
   const [hours, minutes] = timeStr.split(":").map(Number);
   return hours * 60 + (minutes || 0);
@@ -252,16 +256,36 @@ function isErrorWithMessage(error) {
   return typeof error === "object" && error !== null && "message" in error;
 }
 __name(isErrorWithMessage, "isErrorWithMessage");
-function processPrompt(prompt) {
+function processPrompt(prompt, botNames = [], botIds = []) {
   if (!prompt)
     return "";
   if (prompt.includes(":poke"))
     return "戳戳";
+  const names = botNames.filter(Boolean);
+  const ids = botIds.filter(Boolean);
+  prompt = prompt.replace(/<at\b[^>]*?name="([^\"]*)"[^>]*>/gi, (tag, name) => {
+    const id = /\bid="([^"]*)"/i.exec(tag)?.[1];
+    if (ids.includes(id) || names.includes(name))
+      return "";
+    return name;
+  });
+  prompt = prompt.replace(/<at\b[^>]*\/?>/gi, "");
   prompt = prompt.replace(/<[^>]*?avatar[^>]*>/g, "。回复：");
   prompt = prompt.replace(/<[^>]*?img[^>]*>/g, "[图片]");
   prompt = prompt.replace(/<[^>]*?name="([^\"]*)"[^>]*>/g, (_, name) => `${name}`);
+  if (names.length) {
+    const pattern = [...new Set(names.map((name) => name.replace(/[\s,，.。!！?？~～:：;；、]+$/, "")))].filter(Boolean).sort((a, b) => b.length - a.length).map(escapeRegExp).join("|");
+    if (pattern) {
+      const stripped = prompt.replace(
+        new RegExp(`^\\s*(?:${pattern})(?:\\s+|[，,。.!！?？~～:：;；、]+|$)`),
+        ""
+      );
+      if (stripped.trim())
+        prompt = stripped;
+    }
+  }
   prompt = prompt.replace(/\*\*/g, "");
-  if (!prompt)
+  if (!prompt.trim())
     return "**";
   return prompt.trim();
 }
@@ -1205,13 +1229,10 @@ var TOPIC_MAX_TURNS = 20;
 var TOPIC_MAX_AGE_HOURS = 24;
 var MAX_ARCHIVE_DIALOGUES = 200;
 var MAX_CHILDREN_PER_SUMMARY = 100;
-var LEVEL_DAYS = {
-  day: 1,
-  week: 7,
-  month: 28,
-  season: 90,
-  year: 365
-};
+var MAX_LEVEL_NODES_PER_TICK = 10;
+var DEFAULT_MAX_CALLS_PER_TICK = 8;
+var HOUR_MS = 36e5;
+var DAY_MS = 864e5;
 var LEVEL_ORDER = ["day", "week", "month", "season", "year"];
 var CHILD_OF = {
   day: "topic",
@@ -1220,12 +1241,62 @@ var CHILD_OF = {
   season: "month",
   year: "season"
 };
+var DIALOGUE_KINDS = ["turn", "legacy"];
 function formatTime(date, timezoneOffsetHours) {
   const shifted = new Date(new Date(date).getTime() + timezoneOffsetHours * 36e5);
   const pad = /* @__PURE__ */ __name((value) => String(value).padStart(2, "0"), "pad");
   return `${shifted.getUTCFullYear()}/${pad(shifted.getUTCMonth() + 1)}/${pad(shifted.getUTCDate())} ${pad(shifted.getUTCHours())}:${pad(shifted.getUTCMinutes())}`;
 }
 __name(formatTime, "formatTime");
+function dayStart(date, timezoneOffset, boundaryHour) {
+  return lastBoundary(date, timezoneOffset, boundaryHour);
+}
+__name(dayStart, "dayStart");
+function nextDayStart(date, timezoneOffset, boundaryHour) {
+  return new Date(lastBoundary(date, timezoneOffset, boundaryHour).getTime() + DAY_MS);
+}
+__name(nextDayStart, "nextDayStart");
+function periodStart(level, date, timezoneOffset, boundaryHour) {
+  const start = lastBoundary(date, timezoneOffset, boundaryHour);
+  if (level === "day")
+    return start;
+  const offsetMs = timezoneOffset * HOUR_MS;
+  const local = new Date(start.getTime() + offsetMs);
+  const year = local.getUTCFullYear();
+  const month = local.getUTCMonth();
+  if (level === "week") {
+    const back = (local.getUTCDay() + 6) % 7;
+    return new Date(start.getTime() - back * DAY_MS);
+  }
+  if (level === "month") {
+    return new Date(Date.UTC(year, month, 1, boundaryHour) - offsetMs);
+  }
+  if (level === "season") {
+    return new Date(Date.UTC(year, Math.floor(month / 3) * 3, 1, boundaryHour) - offsetMs);
+  }
+  return new Date(Date.UTC(year, 0, 1, boundaryHour) - offsetMs);
+}
+__name(periodStart, "periodStart");
+function periodEnd(level, start, timezoneOffset, boundaryHour) {
+  if (level === "day")
+    return new Date(start.getTime() + DAY_MS);
+  if (level === "week")
+    return new Date(start.getTime() + 7 * DAY_MS);
+  const offsetMs = timezoneOffset * HOUR_MS;
+  const local = new Date(start.getTime() + offsetMs);
+  let year = local.getUTCFullYear();
+  let month = local.getUTCMonth();
+  if (level === "month")
+    month += 1;
+  else if (level === "season")
+    month += 3;
+  else
+    year += 1;
+  year += Math.floor(month / 12);
+  month = (month % 12 + 12) % 12;
+  return new Date(Date.UTC(year, month, 1, boundaryHour) - offsetMs);
+}
+__name(periodEnd, "periodEnd");
 var Summarizer = class {
   constructor(ctx, repo, api, profile, config) {
     this.ctx = ctx;
@@ -1239,6 +1310,12 @@ var Summarizer = class {
   }
   /** 同一 scope 同一时刻只跑一个汇总任务，避免心跳与话题切换并发写入 */
   busy = /* @__PURE__ */ new Set();
+  get tz() {
+    return this.config.timezoneOffset;
+  }
+  get boundaryHour() {
+    return this.config.dayBoundaryHour;
+  }
   // ---------- 话题 ----------
   /**
    * 每轮对话后调用：必要时归档当前话题。
@@ -1251,7 +1328,7 @@ var Summarizer = class {
       const user = await this.lookupUser(scopeId);
       const meta = await this.repo.ensureMeta(scopeId);
       const dialogues = await this.repo.getDialoguesAfter(scopeId, meta.topicStart, {
-        kinds: ["turn", "legacy"],
+        kinds: DIALOGUE_KINDS,
         // 只需要判断是否达到阈值，不把迁移后的全部历史读进内存
         limit: TOPIC_MAX_TURNS
       });
@@ -1261,7 +1338,7 @@ var Summarizer = class {
       if (!shouldSwitch) {
         const text = this.formatDialogues(dialogues);
         const result = await this.api.auxiliaryChat(
-          buildTopicSwitchPrompt(text, formatTime(meta.topicStart, this.config.timezoneOffset)),
+          buildTopicSwitchPrompt(text, formatTime(meta.topicStart, this.tz)),
           user
         );
         if (result.error)
@@ -1273,123 +1350,255 @@ var Summarizer = class {
         await this.archiveTopicLocked(scopeId, user);
     });
   }
-  /** 兜底：话题持续时间过长时强制归档一次，否则金字塔会断在 topic 级 */
-  async archiveStaleTopic(scopeId, user) {
-    const meta = await this.repo.ensureMeta(scopeId);
-    const ageHours = (Date.now() - new Date(meta.topicStart).getTime()) / 36e5;
-    if (ageHours < TOPIC_MAX_AGE_HOURS)
-      return;
-    const dialogues = await this.repo.getDialoguesAfter(scopeId, meta.topicStart, {
-      kinds: ["turn", "legacy"],
-      limit: 1
-    });
-    if (!dialogues.length)
-      return;
-    await this.archiveTopicLocked(scopeId, user);
-  }
-  /** 把 [topicStart, 末尾] 的对话归档为一条 topic 记忆。调用方需持有 busy 锁。 */
+  /**
+   * 把游标所在自然日内、尚未归档的对话归档为一条 topic 记忆。
+   * 超过 MAX_ARCHIVE_DIALOGUES 时只取前 200 条（同一天拆成多块）。
+   * 返回是否真的发起并完成了归档。
+   */
   async archiveTopicLocked(scopeId, user) {
     const meta = await this.repo.ensureMeta(scopeId);
-    const dialogues = await this.repo.getDialoguesAfter(scopeId, meta.topicStart, {
-      kinds: ["turn", "legacy"],
-      limit: MAX_ARCHIVE_DIALOGUES
+    const cursor = new Date(meta.topicStart);
+    const dayEnd = nextDayStart(cursor, this.tz, this.boundaryHour);
+    const dialogues = await this.repo.getDialoguesAfter(scopeId, cursor, {
+      kinds: DIALOGUE_KINDS,
+      limit: MAX_ARCHIVE_DIALOGUES,
+      before: dayEnd
     });
     if (!dialogues.length)
-      return;
+      return false;
     const text = this.formatDialogues(dialogues);
     if (this.config.dryRun) {
-      logger4.info(`[dry-run] topic 归档 scope=${scopeId} 对话=${dialogues.length} 字符=${text.length}`);
-      return;
+      logger4.info(`[dry-run] topic 归档 scope=${scopeId} 对话=${dialogues.length} 字符=${text.length} 日=${formatTime(cursor, this.tz)}`);
+      return false;
     }
     const result = await this.api.auxiliaryChat(buildTopicArchivePrompt(text), user);
     if (result.error) {
       logger4.warn(`topic 归档失败 scope=${scopeId}: ${result.content}`);
-      return;
+      return false;
     }
     const parsed = parseLlmJson(result.content);
     const summary = parsed?.summary?.trim();
     if (!summary) {
       logger4.warn(`topic 归档解析失败 scope=${scopeId}: ${result.content?.slice(0, 200)}`);
-      return;
+      return false;
     }
-    const periodStart = dialogues[0].createdAt;
+    const periodStart2 = dialogues[0].createdAt;
     const last = dialogues[dialogues.length - 1];
+    let nextCursor = new Date(last.createdAt);
+    if (dayEnd.getTime() <= Date.now()) {
+      const remaining2 = await this.repo.countDialoguesInRange(
+        scopeId,
+        nextCursor,
+        dayEnd,
+        DIALOGUE_KINDS
+      );
+      if (!remaining2)
+        nextCursor = dayEnd;
+    }
     await this.repo.commitTopicArchive({
       scopeId,
       granularity: "topic",
       topic: (parsed.topic || "").trim(),
       content: summary,
       userState: (parsed.user_state || "").trim(),
-      periodStart,
+      periodStart: periodStart2,
       periodEnd: last.createdAt,
       sourceCount: dialogues.length,
       createdAt: /* @__PURE__ */ new Date()
-    }, scopeId, new Date(last.createdAt));
-    const remaining = await this.repo.countDialoguesAfter(scopeId, new Date(last.createdAt));
-    logger4.info(`topic 归档完成 scope=${scopeId} 对话=${dialogues.length}${remaining ? ` 剩余${remaining}条待处理` : ""}`);
+    }, scopeId, nextCursor);
+    const remaining = await this.repo.countDialoguesAfter(scopeId, nextCursor);
+    logger4.info(`topic 归档完成 scope=${scopeId} 对话=${dialogues.length} 日=${formatTime(dayStart(cursor, this.tz, this.boundaryHour), this.tz)}` + (remaining ? ` 剩余${remaining}条待处理` : ""));
+    return true;
+  }
+  /**
+   * 按自然日消费积压：每次归档一个日块，直到预算用完。
+   * - 全是空白的日期用一次查询跨过去，不逐天循环；
+   * - 已关闭的日子必须归档干净（哪怕只剩 1 条），否则日级永远等不到闭合；
+   * - 进行中的当天沿用旧语义：话题超过 24 小时才兜底归档。
+   */
+  async drainTopics(scopeId, user, budget) {
+    if (this.config.dryRun) {
+      const meta = await this.repo.ensureMeta(scopeId);
+      const [next] = await this.repo.getDialoguesAfter(scopeId, meta.topicStart, {
+        kinds: DIALOGUE_KINDS,
+        limit: 1
+      });
+      if (next)
+        logger4.info(`[dry-run] 将归档 scope=${scopeId} 起点=${formatTime(next.createdAt, this.tz)}`);
+      return;
+    }
+    while (budget.calls > 0) {
+      const meta = await this.repo.ensureMeta(scopeId);
+      const cursor = new Date(meta.topicStart);
+      const dayEnd = nextDayStart(cursor, this.tz, this.boundaryHour);
+      const [next] = await this.repo.getDialoguesAfter(scopeId, cursor, {
+        kinds: DIALOGUE_KINDS,
+        limit: 1
+      });
+      if (!next) {
+        const todayStart = dayStart(/* @__PURE__ */ new Date(), this.tz, this.boundaryHour);
+        if (todayStart.getTime() > cursor.getTime()) {
+          await this.repo.setTopicStart(scopeId, todayStart);
+        }
+        return;
+      }
+      const nextDay = dayStart(new Date(next.createdAt), this.tz, this.boundaryHour);
+      if (nextDay.getTime() > cursor.getTime()) {
+        await this.repo.setTopicStart(scopeId, nextDay);
+        continue;
+      }
+      if (dayEnd.getTime() > Date.now()) {
+        const ageHours = (Date.now() - cursor.getTime()) / HOUR_MS;
+        if (ageHours < TOPIC_MAX_AGE_HOURS)
+          return;
+      }
+      const archived = await this.archiveTopicLocked(scopeId, user);
+      if (!archived)
+        return;
+      budget.calls -= 1;
+    }
   }
   // ---------- 分层汇总 ----------
   async summarizeScope(scopeId) {
     return this.runExclusive(scopeId, async () => {
       const user = await this.lookupUser(scopeId);
       await this.repo.touchMeta(scopeId);
-      await this.archiveStaleTopic(scopeId, user);
-      for (const level of LEVEL_ORDER) {
-        await this.summarizeLevel(scopeId, level, user);
-      }
+      const total = Math.max(2, this.config.maxCallsPerTick ?? DEFAULT_MAX_CALLS_PER_TICK);
+      const archiveQuota = Math.max(1, Math.floor(total / 2));
+      const archiveBudget = { calls: archiveQuota };
+      await this.drainTopics(scopeId, user, archiveBudget);
+      const levelBudget = {
+        calls: Math.max(1, total - (archiveQuota - archiveBudget.calls))
+      };
+      await this.buildLevels(scopeId, user, levelBudget);
     });
   }
-  async summarizeLevel(scopeId, level, user) {
-    const now = /* @__PURE__ */ new Date();
-    const cutoff = level === "day" ? lastBoundary(now, this.config.timezoneOffset, this.config.dayBoundaryHour) : new Date(now.getTime() - LEVEL_DAYS[level] * 864e5);
-    const parent = await this.repo.getLatestMemory(scopeId, level);
-    const from = parent ? new Date(parent.periodEnd) : null;
-    const children = (await this.repo.getMemoriesInRange(
-      scopeId,
-      CHILD_OF[level],
-      from,
-      cutoff
-    )).slice(0, MAX_CHILDREN_PER_SUMMARY);
-    if (!children.length)
-      return;
-    const text = this.formatChildren(children);
-    if (this.config.dryRun) {
-      logger4.info(`[dry-run] ${level} 汇总 scope=${scopeId} 子记忆=${children.length} 字符=${text.length} 区间=${formatTime(children[0].periodStart, this.config.timezoneOffset)}~${formatTime(children[children.length - 1].periodEnd, this.config.timezoneOffset)}`);
-      return;
-    }
-    const result = await this.api.auxiliaryChat(buildSummaryPrompt(level, text), user);
-    if (result.error) {
-      logger4.warn(`${level} 汇总失败 scope=${scopeId}: ${result.content}`);
-      return;
-    }
-    const parsed = parseLlmJson(result.content);
-    const summary = parsed?.summary?.trim();
-    if (!summary) {
-      logger4.warn(`${level} 汇总解析失败 scope=${scopeId}: ${result.content?.slice(0, 200)}`);
-      return;
-    }
-    const first = children[0];
-    const last = children[children.length - 1];
-    await this.repo.createMemory({
-      scopeId,
-      granularity: level,
-      topic: "",
-      content: summary,
-      userState: (parsed.user_state || "").trim(),
-      periodStart: new Date(first.periodStart),
-      periodEnd: new Date(last.periodEnd),
-      sourceCount: children.length,
-      createdAt: /* @__PURE__ */ new Date()
-    });
-    logger4.info(`${level} 汇总完成 scope=${scopeId} 子记忆=${children.length}`);
-    if (level === "day") {
-      await this.profile.summarize(scopeId, summary, children, user);
+  /**
+   * 自下而上补齐已闭合的周期，每个周期最多一条节点。
+   *
+   * 起算点来自该层最新节点的 periodEnd（没有则取最早子节点所在周期），
+   * 因此不会重复生成同一周期；空周期没有子节点，会被自然跳过。
+   * 周期末尾晚于归档游标时说明周期内的对话还没归档完，立即停止该层。
+   */
+  async buildLevels(scopeId, user, budget) {
+    const meta = await this.repo.ensureMeta(scopeId);
+    const frontier = new Date(meta.topicStart);
+    for (const level of LEVEL_ORDER) {
+      let nodes = 0;
+      let reached = false;
+      while (nodes < MAX_LEVEL_NODES_PER_TICK) {
+        const parent = await this.repo.getLatestMemory(scopeId, level);
+        const from = parent ? new Date(parent.periodEnd) : null;
+        const [child] = await this.repo.getMemoriesInRange(
+          scopeId,
+          CHILD_OF[level],
+          from,
+          frontier,
+          1
+        );
+        if (!child) {
+          reached = true;
+          break;
+        }
+        const start = periodStart(level, new Date(new Date(child.periodEnd).getTime() - 1), this.tz, this.boundaryHour);
+        const end = periodEnd(level, start, this.tz, this.boundaryHour);
+        if (end.getTime() > frontier.getTime()) {
+          reached = true;
+          break;
+        }
+        const children = await this.repo.getMemoriesInRange(
+          scopeId,
+          CHILD_OF[level],
+          start,
+          end
+        );
+        if (!children.length)
+          break;
+        if (level === "day") {
+          const stray = children.find((row) => dayStart(new Date(row.periodStart), this.tz, this.boundaryHour).getTime() !== dayStart(new Date(new Date(row.periodEnd).getTime() - 1), this.tz, this.boundaryHour).getTime());
+          if (stray) {
+            logger4.warn(`day 汇总暂停：存在跨日 topic 记忆 scope=${scopeId} 记忆区间=${formatTime(stray.periodStart, this.tz)} ~ ${formatTime(stray.periodEnd, this.tz)}`);
+            break;
+          }
+        }
+        const range = `${formatTime(start, this.tz)} ~ ${formatTime(end, this.tz)}`;
+        const single = children.length === 1;
+        if (single) {
+          if (this.config.dryRun) {
+            logger4.info(`[dry-run] ${level} 晋升 scope=${scopeId} 周期=${range} 子记忆=1`);
+            return;
+          }
+          if (level === "day" && this.profile.isEnabled()) {
+            if (budget.calls <= 0)
+              return;
+            budget.calls -= 1;
+            await this.profile.summarize(scopeId, children[0].content, children, user);
+          }
+          await this.repo.createMemory({
+            scopeId,
+            granularity: level,
+            topic: "",
+            content: children[0].content,
+            userState: children[0].userState || "",
+            periodStart: start,
+            periodEnd: end,
+            sourceCount: 1,
+            createdAt: /* @__PURE__ */ new Date()
+          });
+          logger4.info(`${level} 晋升 scope=${scopeId} 周期=${range}`);
+          nodes += 1;
+          continue;
+        }
+        const need = 1 + (level === "day" && this.profile.isEnabled() ? 1 : 0);
+        if (budget.calls < need)
+          return;
+        const input = children.slice(0, MAX_CHILDREN_PER_SUMMARY);
+        if (children.length > MAX_CHILDREN_PER_SUMMARY) {
+          logger4.warn(`${level} 子记忆过多，只汇总前 ${MAX_CHILDREN_PER_SUMMARY} 条 scope=${scopeId} 实际=${children.length}`);
+        }
+        const text = this.formatChildren(input);
+        if (this.config.dryRun) {
+          logger4.info(`[dry-run] ${level} 汇总 scope=${scopeId} 周期=${range} 子记忆=${children.length}`);
+          return;
+        }
+        const result = await this.api.auxiliaryChat(buildSummaryPrompt(level, text), user);
+        budget.calls -= 1;
+        if (result.error) {
+          logger4.warn(`${level} 汇总失败 scope=${scopeId}: ${result.content}`);
+          return;
+        }
+        const parsed = parseLlmJson(result.content);
+        const summary = parsed?.summary?.trim();
+        if (!summary) {
+          logger4.warn(`${level} 汇总解析失败 scope=${scopeId}: ${result.content?.slice(0, 200)}`);
+          return;
+        }
+        await this.repo.createMemory({
+          scopeId,
+          granularity: level,
+          topic: "",
+          content: summary,
+          userState: (parsed.user_state || "").trim(),
+          periodStart: start,
+          periodEnd: end,
+          sourceCount: children.length,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+        logger4.info(`${level} 汇总完成 scope=${scopeId} 周期=${range} 子记忆=${children.length}`);
+        nodes += 1;
+        if (level === "day" && this.profile.isEnabled()) {
+          budget.calls -= 1;
+          await this.profile.summarize(scopeId, summary, children, user);
+        }
+      }
+      if (!reached)
+        return;
     }
   }
   // ---------- 工具 ----------
   formatDialogues(rows) {
     return rows.map((row) => {
-      const time = formatTime(row.createdAt, this.config.timezoneOffset);
+      const time = formatTime(row.createdAt, this.tz);
       const user = row.username || "用户";
       const ai = row.aiContent && row.aiContent !== "…" ? `
 AI：${row.aiContent}` : "";
@@ -1398,7 +1607,7 @@ AI：${row.aiContent}` : "";
   }
   formatChildren(children) {
     return children.map((child) => {
-      const range = `${formatTime(child.periodStart, this.config.timezoneOffset)} ~ ${formatTime(child.periodEnd, this.config.timezoneOffset)}`;
+      const range = `${formatTime(child.periodStart, this.tz)} ~ ${formatTime(child.periodEnd, this.tz)}`;
       const topic = child.topic ? `（${child.topic}）` : "";
       const state = child.userState ? `
 用户状态：${child.userState}` : "";
@@ -2024,6 +2233,9 @@ var ProfileManager = class {
   static {
     __name(this, "ProfileManager");
   }
+  isEnabled() {
+    return this.config.enabled;
+  }
   /** 日总结完成后调用；持票用户走自己的 key（与 chat 一致） */
   async summarize(scopeId, summary, memories, user = null) {
     if (!this.config.enabled)
@@ -2134,7 +2346,10 @@ var MemoryRepository = class {
     });
   }
   async getDialoguesAfter(scopeId, after, options) {
-    const query = { scopeId, createdAt: { $gt: after } };
+    const createdAt = { $gt: after };
+    if (options?.before)
+      createdAt.$lt = options.before;
+    const query = { scopeId, createdAt };
     if (options?.kinds?.length)
       query.kind = { $in: options.kinds };
     return this.ctx.database.get("sat_dialogue", query, {
@@ -2149,6 +2364,14 @@ var MemoryRepository = class {
     const rows = await this.ctx.database.get("sat_dialogue", query, { fields: ["id"] });
     return rows.length;
   }
+  /** after < createdAt < before 的对话数，用于判断一个已关闭的日块是否归档干净 */
+  async countDialoguesInRange(scopeId, after, before, kinds) {
+    const query = { scopeId, createdAt: { $gt: after, $lt: before } };
+    if (kinds?.length)
+      query.kind = { $in: kinds };
+    const rows = await this.ctx.database.get("sat_dialogue", query, { fields: ["id"] });
+    return rows.length;
+  }
   async countDialogues(scopeId) {
     const rows = await this.ctx.database.get("sat_dialogue", { scopeId }, { fields: ["id"] });
     return rows.length;
@@ -2250,12 +2473,13 @@ var MemoryRepository = class {
     return rows[0]?.periodStart || null;
   }
   /** 区间查询：from < periodEnd <= to，走真正的 SQL 条件而不是 JS 侧过滤 */
-  async getMemoriesInRange(scopeId, granularity, from, to) {
-    const periodEnd = { $lte: to };
+  async getMemoriesInRange(scopeId, granularity, from, to, limit) {
+    const periodEnd2 = { $lte: to };
     if (from)
-      periodEnd.$gt = from;
-    return this.ctx.database.get("sat_memory", { scopeId, granularity, periodEnd }, {
-      sort: { periodEnd: "asc" }
+      periodEnd2.$gt = from;
+    return this.ctx.database.get("sat_memory", { scopeId, granularity, periodEnd: periodEnd2 }, {
+      sort: { periodEnd: "asc" },
+      limit
     });
   }
   async createMemory(row) {
@@ -2468,6 +2692,7 @@ var MemoryService = class {
       topicSwitchCheck: config.topic_switch_check,
       timezoneOffset: config.memory_timezone_offset,
       dayBoundaryHour: config.memory_day_boundary_hour,
+      maxCallsPerTick: config.summary_max_calls_per_tick,
       resolveUser
     });
     this.contextBuilder = new ContextBuilder(this.repo, this.shortTerm, this.profile, {
@@ -3013,6 +3238,7 @@ var Sat = class extends import_koishi10.Service {
       topic_switch_check: import_koishi10.Schema.boolean().default(true).description("是否用辅助模型判断话题切换"),
       summary_heartbeat_minutes: import_koishi10.Schema.number().default(10).description("后台汇总心跳间隔（分钟）"),
       summary_max_scopes_per_tick: import_koishi10.Schema.number().default(3).description("每次心跳最多处理的用户/群数量"),
+      summary_max_calls_per_tick: import_koishi10.Schema.number().default(8).description("每个用户/群每次心跳最多发起的辅助模型调用数（归档与分层汇总各占一半预算；历史积压时调大可加快补齐）"),
       memory_active_window_days: import_koishi10.Schema.number().default(7).description("只对最近多少天内活跃过的用户/群做汇总"),
       memory_retention_days: import_koishi10.Schema.number().default(180).description("原始对话保留天数"),
       memory_recall_topN: import_koishi10.Schema.number().default(5).description("关键词召回的历史记忆条数"),
@@ -5382,6 +5608,7 @@ var SAT = class extends Sat {
       summary_heartbeat_minutes: this.config.summary_heartbeat_minutes,
       summary_dry_run: this.config.summary_dry_run,
       summary_max_scopes_per_tick: this.config.summary_max_scopes_per_tick,
+      summary_max_calls_per_tick: this.config.summary_max_calls_per_tick,
       memory_active_window_days: this.config.memory_active_window_days,
       memory_retention_days: this.config.memory_retention_days,
       memory_context_max_chars: this.config.memory_context_max_chars,
@@ -5627,7 +5854,7 @@ var SAT = class extends Sat {
   }
   // 处理输入
   async processInput(session, prompt) {
-    const processedPrompt = processPrompt(prompt);
+    const processedPrompt = processPrompt(prompt, this.config.nick_name_list, [session.selfId]);
     let censored = processedPrompt;
     if (this.ctx.censor) {
       censored = await this.ctx.censor.transform(processedPrompt, session);
@@ -6010,7 +6237,7 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
   }
   // 频道记忆中间件转接
   async handleChannelMemoryManager(session) {
-    const processedPrompt = processPrompt(session.content);
+    const processedPrompt = processPrompt(session.content, this.config.nick_name_list, [session.selfId]);
     if (this.performPreChecks(session, processedPrompt))
       return null;
     let censored = processedPrompt;

package/lib/memory/index.d.ts

@@ -10,6 +10,7 @@ export interface MemoryServiceConfig extends MemoryConfig {
     summary_heartbeat_minutes: number;
     summary_dry_run: boolean;
     summary_max_scopes_per_tick: number;
+    summary_max_calls_per_tick: number;
     memory_active_window_days: number;
     memory_retention_days: number;
     memory_context_max_chars: number;

package/lib/memory/profile.d.ts

@@ -15,6 +15,7 @@ export declare class ProfileManager {
     private api;
     private config;
     constructor(ctx: Context, repo: MemoryRepository, api: APIClient, config: ProfileConfig);
+    isEnabled(): boolean;
     /** 日总结完成后调用；持票用户走自己的 key（与 chat 一致） */
     summarize(scopeId: string, summary: string, memories: SatMemory[], user?: User | null): Promise<void>;
     getContext(scopeId: string): Promise<string>;

package/lib/memory/repository.d.ts

@@ -12,8 +12,11 @@ export declare class MemoryRepository {
     getDialoguesAfter(scopeId: string, after: Date, options?: {
         kinds?: string[];
         limit?: number;
+        before?: Date;
     }): Promise<SatDialogue[]>;
     countDialoguesAfter(scopeId: string, after: Date, kinds?: string[]): Promise<number>;
+    /** after < createdAt < before 的对话数，用于判断一个已关闭的日块是否归档干净 */
+    countDialoguesInRange(scopeId: string, after: Date, before: Date, kinds?: string[]): Promise<number>;
     countDialogues(scopeId: string): Promise<number>;
     /** 只清理普通对话，legacy 迁移数据保留（一次性数据，量有界） */
     pruneDialogues(before: Date): Promise<number>;
@@ -44,7 +47,7 @@ export declare class MemoryRepository {
     /** 子粒度的最早起点（服务端 ORDER BY periodStart ASC LIMIT 1，等价于 MIN(periodStart)） */
     getEarliestChildStart(scopeId: string, granularity: Granularity): Promise<Date | null>;
     /** 区间查询：from < periodEnd <= to，走真正的 SQL 条件而不是 JS 侧过滤 */
-    getMemoriesInRange(scopeId: string, granularity: Granularity, from: Date | null, to: Date): Promise<SatMemory[]>;
+    getMemoriesInRange(scopeId: string, granularity: Granularity, from: Date | null, to: Date, limit?: number): Promise<SatMemory[]>;
     createMemory(row: Omit<SatMemory, 'id'>): Promise<void>;
     /** 该 scope 是否已经产过分层记忆（用于判断迁移是否第一次跑） */
     hasAnyMemory(scopeId: string): Promise<boolean>;

package/lib/memory/summarizer.d.ts

@@ -8,15 +8,31 @@ export declare const TOPIC_MAX_TURNS = 20;
 export declare const TOPIC_MAX_AGE_HOURS = 24;
 export declare const MAX_ARCHIVE_DIALOGUES = 200;
 export declare const MAX_CHILDREN_PER_SUMMARY = 100;
+/** 单个 scope 一次心跳里最多建立多少个层级节点，防止历史积压把 tick 拖死 */
+export declare const MAX_LEVEL_NODES_PER_TICK = 10;
+/** 每次心跳默认的辅助模型调用上限（归档 + 多子节点汇总 + 日画像） */
+export declare const DEFAULT_MAX_CALLS_PER_TICK = 8;
+declare const LEVEL_ORDER: readonly ["day", "week", "month", "season", "year"];
+type Level = typeof LEVEL_ORDER[number];
 export interface SummarizerConfig {
     dryRun: boolean;
     topicSwitchCheck: boolean;
     timezoneOffset: number;
     dayBoundaryHour: number;
+    /** 每个 scope 每次汇总最多发起多少次辅助模型调用 */
+    maxCallsPerTick?: number;
     /** scopeId -> 用户；用于让持“地灵殿通行证”的用户走自己的 key */
     resolveUser?: (scopeId: string) => Promise<User | null>;
 }
 export declare function formatTime(date: Date, timezoneOffsetHours: number): string;
+/** date 所在自然日的起点：最近一个已过的日界线 */
+export declare function dayStart(date: Date, timezoneOffset: number, boundaryHour: number): Date;
+/** date 所在自然日的终点（下一条日界线） */
+export declare function nextDayStart(date: Date, timezoneOffset: number, boundaryHour: number): Date;
+/** date 所属的 level 周期起点：日 / 周一 / 月 / 季 / 年，均落在日界线上 */
+export declare function periodStart(level: Level, date: Date, timezoneOffset: number, boundaryHour: number): Date;
+/** level 周期的下一个起点（= 当前周期的终点） */
+export declare function periodEnd(level: Level, start: Date, timezoneOffset: number, boundaryHour: number): Date;
 export declare class Summarizer {
     private ctx;
     private repo;
@@ -26,20 +42,39 @@ export declare class Summarizer {
     /** 同一 scope 同一时刻只跑一个汇总任务，避免心跳与话题切换并发写入 */
     private busy;
     constructor(ctx: Context, repo: MemoryRepository, api: APIClient, profile: ProfileManager, config: SummarizerConfig);
+    private get tz();
+    private get boundaryHour();
     /**
      * 每轮对话后调用：必要时归档当前话题。
      * 注意：这里不阻塞回复，由调用方以 fire-and-forget 方式触发。
      */
     maybeSwitchTopic(scopeId: string): Promise<void>;
-    /** 兜底：话题持续时间过长时强制归档一次，否则金字塔会断在 topic 级 */
-    private archiveStaleTopic;
-    /** 把 [topicStart, 末尾] 的对话归档为一条 topic 记忆。调用方需持有 busy 锁。 */
+    /**
+     * 把游标所在自然日内、尚未归档的对话归档为一条 topic 记忆。
+     * 超过 MAX_ARCHIVE_DIALOGUES 时只取前 200 条（同一天拆成多块）。
+     * 返回是否真的发起并完成了归档。
+     */
     private archiveTopicLocked;
+    /**
+     * 按自然日消费积压：每次归档一个日块，直到预算用完。
+     * - 全是空白的日期用一次查询跨过去，不逐天循环；
+     * - 已关闭的日子必须归档干净（哪怕只剩 1 条），否则日级永远等不到闭合；
+     * - 进行中的当天沿用旧语义：话题超过 24 小时才兜底归档。
+     */
+    private drainTopics;
     summarizeScope(scopeId: string): Promise<void>;
-    private summarizeLevel;
+    /**
+     * 自下而上补齐已闭合的周期，每个周期最多一条节点。
+     *
+     * 起算点来自该层最新节点的 periodEnd（没有则取最早子节点所在周期），
+     * 因此不会重复生成同一周期；空周期没有子节点，会被自然跳过。
+     * 周期末尾晚于归档游标时说明周期内的对话还没归档完，立即停止该层。
+     */
+    private buildLevels;
     private formatDialogues;
     private formatChildren;
     /** 解析失败不应让后台归档整体失败，退回默认辅助模型即可。 */
     private lookupUser;
     private runExclusive;
 }
+export {};

package/lib/types.d.ts

@@ -196,6 +196,7 @@ export declare namespace Sat {
         summary_heartbeat_minutes: number;
         summary_dry_run: boolean;
         summary_max_scopes_per_tick: number;
+        summary_max_calls_per_tick: number;
         memory_active_window_days: number;
         memory_retention_days: number;
         memory_context_max_chars: number;

package/lib/utils.d.ts

@@ -15,9 +15,12 @@ export declare function isErrorWithMessage(error: unknown): error is {
 };
 /**
  * @param prompt 包含待处理标签的原始字符串
+ * @param botNames bot 的称呼列表；用于去掉 @bot / 以昵称开场这类「称呼」，
+ *   它们只是唤起方式，不应该进入对话记录与总结
+ * @param botIds bot 的账号 id；群名片可能改得和正文很像，优先用 id 判断 @ 的是不是 bot
  * @returns 处理后的字符串，所有匹配标签被替换为对应名称
  */
-export declare function processPrompt(prompt: string): string;
+export declare function processPrompt(prompt: string, botNames?: string[], botIds?: string[]): string;
 /**
  * @param prompt 包含待处理标签的原始字符串
  * @param words 需要过滤的关键词

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-satori-ai",
   "description": "基于 Satori 适配器的智能对话插件，具备用户画像、长期记忆、常识管理和好感度系统",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "types": "lib/index.d.ts",