dsh-feini 0.1.6 → 0.1.7

package/README.md

@@ -28,6 +28,11 @@
 | 提醒 | 「十点提醒我」这种，到点它主动喊你 |
 | 联网 | 问到天气/价格/赛果/版本这类会现查（需要智谱 key），查不到就说没查到 |
 | 主动找你 | 闲一阵会主动开口；你太久不理它，它会闹点小脾气，哄两句才好 |
+| 生日 | 第一次聊到日子会问一次你的生日，记着但不主动提；到那天问候，而且一整天都能围着生日聊 |
+| 早上问候 | 你说了晚安就进入静默（夜里再说话会顺延），到早上先来一句「早上好」，之后不回才开始攒小脾气 |
+| 到了吗 | 你说拜拜出门，下次开口时顺口问一句到没到，不单排定时 |
+| 表情认重 | 同一张表情包被重压过也能认出来（按识图描述比对），认出来不重复解释 |
+| 自己的主意 | 会顶嘴、会说不想，也有自己感兴趣和讨厌的东西 |
 
 ## 需要准备
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-feini",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "菲妮做的 QQ 陪伴插件：一张空白人设、一本笔记本、一套会攒记忆的规矩，让你自己养自己的伙伴。",
   "author": "Feini",
   "icon": "assets/logo.svg",

package/src/anger.mjs

@@ -8,7 +8,7 @@
  * - 哄好只消当下的气，但「账」记着（strikes），下次再犯直接跳回更高一级
  * - 七天没再犯，账减一笔；但不会凭空清零
  *
- * 状态存数据目录下的 anger.json
+ * 状态存 D:\QQBridge\anger.json
  */
 import fs from 'node:fs';
 

package/src/arrival.mjs

@@ -0,0 +1,43 @@
+/**
+ * 「他出门了，问一句到了吗」——不单独排定时，借下一次开口带出来。
+ *
+ * 他拜拜/出门的时候在 away.json 里记一笔 needArrival；
+ * 下一次主动聊天、或者他先说话时，system 里带上这段提示，问过就标记 asked，不再重复。
+ */
+import fs from 'node:fs';
+
+const TTL = 3 * 3600 * 1000;
+
+export function arrivalNote(file) {
+  try {
+    const s = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!s?.needArrival || s.asked) return '';
+    if (Date.now() - Number(s.at || 0) > TTL) return '';
+    return (
+      '\n\n【他出门了】他刚才说要出门/拜拜，还没确认到没到。' +
+      '这句要是你主动开口，就顺口问一句「到了吗」；要是他先说话，就接一句关心（到了就好），别像查岗。'
+    );
+  } catch {
+    return '';
+  }
+}
+
+export function markArrivalAsked(file) {
+  try {
+    const s = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!s?.needArrival || s.asked) return;
+    s.asked = true;
+    s.askedAt = Date.now();
+    fs.writeFileSync(file, JSON.stringify(s), 'utf8');
+  } catch {
+    /* 记不上就算了 */
+  }
+}
+
+export function markLeaving(file, what = '出门') {
+  try {
+    fs.writeFileSync(file, JSON.stringify({ what, at: Date.now(), needArrival: true, asked: false }), 'utf8');
+  } catch {
+    /* 记不上就算了 */
+  }
+}

package/src/birthday.mjs

@@ -0,0 +1,100 @@
+/**
+ * 生日：只问一次，记一辈子，平时不主动提，到他生日那天问候。
+ *
+ * 规则（他定的）：
+ * - 第一次聊到日子（「什么日子」「节日」「几号」）时，顺口问一次生日；
+ * - 记下来，但平时不主动提——只有生日当天才问候；
+ * - 他问起来可以说，但按人设委婉说，别像查档案。
+ */
+import fs from 'node:fs';
+
+const DATE_CN = /(\d{1,2})\s*月\s*(\d{1,2})\s*[日号]/;
+const DATE_SLASH = /(?:^|\D)(\d{1,2})[/-](\d{1,2})(?:\D|$)/;
+const DATE_WORD_RE = /(什么日子|今天几号|星期几|节日|日期|几月|几号|生日|纪念日)/;
+
+function load(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function save(file, s) {
+  try {
+    fs.writeFileSync(file, JSON.stringify(s), 'utf8');
+  } catch {
+    /* 记不上就算了 */
+  }
+}
+
+const pad = (n) => String(n).padStart(2, '0');
+
+export function birthdayOf(file) {
+  return String(load(file).birthday || '');
+}
+
+/** 他这句里报了生日就记下来（问过之后三小时内认得更松） */
+export function captureBirthday(file, text) {
+  const t = String(text || '');
+  const s = load(file);
+  if (s.birthday) return { saved: false };
+  const m = t.match(DATE_CN) || t.match(DATE_SLASH);
+  if (!m) return { saved: false };
+  const mm = Number(m[1]);
+  const dd = Number(m[2]);
+  if (!(mm >= 1 && mm <= 12 && dd >= 1 && dd <= 31)) return { saved: false };
+  const looksRight = /(生日|出生|哪天生)/.test(t) || Date.now() - Number(s.askedAt || 0) < 3 * 3600 * 1000;
+  if (!looksRight) return { saved: false };
+  s.birthday = `${pad(mm)}-${pad(dd)}`;
+  s.capturedAt = Date.now();
+  save(file, s);
+  return { saved: true, birthday: s.birthday };
+}
+
+/** 他第一次聊到日子：问一次生日，问过就不再问 */
+export function askHint(file, text) {
+  const t = String(text || '');
+  const s = load(file);
+  if (s.birthday || s.asked) return '';
+  if (!DATE_WORD_RE.test(t)) return '';
+  s.asked = Date.now();
+  save(file, s);
+  return (
+    '\n\n【第一次聊到日子】他提到日子了。顺口问一句他生日是哪天，就这一次，' +
+    '语气自然点、带点你自己的性子，别像填表；问完以后不主动提，等他生日那天再用。'
+  );
+}
+
+/** 生日当天才提；一年只提一次 */
+export function todayHint(file, now = new Date()) {
+  const s = load(file);
+  if (!s.birthday) return '';
+  const today = `${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+  if (today !== s.birthday) return '';
+  if (Number(s.greetedYear) === now.getFullYear()) {
+    // 当天可以说一整天，只是别把「生日快乐」翻来覆去地念
+    return (
+      '\n\n【今天还是他生日】生日话题可以接着聊——今天怎么过的、想吃什么、要不要什么礼物，' +
+      '都顺着他聊；但别再重复说「生日快乐」，也别一开口就绕着生日转，他聊别的就正常接。'
+    );
+  }
+  return (
+    '\n\n【今天是他生日】今天是他的生日。第一句就跟他说生日快乐，' +
+    '用你自己的方式说，别像系统通知；这一天都可以围绕生日聊，别整段念祝福词。'
+  );
+}
+
+export function markGreeted(file, now = new Date()) {
+  const s = load(file);
+  if (!s.birthday) return;
+  const today = `${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+  if (today !== s.birthday) return;
+  s.greetedYear = now.getFullYear();
+  save(file, s);
+}
+
+/** 一直挂在 system 里的规矩 */
+export const BIRTHDAY_RULE =
+  '\n\n【生日·记着但不主动提】你知道他的生日，但平时绝不主动提；只有生日当天才提，那天可以聊一整天。' +
+  '他问起来可以说，但要按你的性子委婉说——比如先绕个弯、傲娇一下再说，别像查档案。';

package/src/bridge.mjs

@@ -38,12 +38,15 @@ import { takeInterest, addInterest, removeInterest, interestsLine, INTEREST_RULE
 import { startInterestReview } from './review.mjs';
 import { seaLine } from './sea.mjs';
 import { planHint } from './guess-plan.mjs';
+import { arrivalNote, markArrivalAsked, markLeaving } from './arrival.mjs';
+import { BIRTHDAY_RULE, askHint, captureBirthday, markGreeted, todayHint } from './birthday.mjs';
 import { takeGuess, addGuess, resolveGuess, guessesLine, GUESS_RULE } from './guess.mjs';
 import { ANGER_RULE, angerLine, offend, coaxed, looksLikeCoax } from './anger.mjs';
 import { getBalance, BALANCE_RULE } from './balance.mjs';
 import { addUsage, usageSummary, USAGE_RULE } from './usage.mjs';
 import { createDiary } from './diary.mjs';
 import { onUsage } from './llm.mjs';
+import { buildSea } from './build-sea.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const root = process.env.DSH_FEINI_HOME ? path.resolve(process.env.DSH_FEINI_HOME) : path.resolve(here, '..');
@@ -139,6 +142,17 @@ const POUT_RULE =
   '他说「迟到了」「我还是迟到了」又没指明是哪件事，默认就是迟回来找我聊天——别猜成别的约会，' +
   '也别回「原来是迟到这件事呀」这种没接住的话，直接顺着「迟了来找我」接（「原来是迟了来找我呀，那这笔账我可得算算」）。';
 
+// 问吃饭先看钟：三点问晚饭、或者他刚说吃过还问同一顿，都显得没在听
+// 他也说过：别什么都顺着他，我有自己的主意和感兴趣的东西
+const SELF_RULE =
+  '\n\n【你也有自己的主意】别什么都顺着他：真不同意就说出来，可以顶一句嘴、可以不接他的玩笑、可以说「我不想」。\n' +
+  '你有自己感兴趣的和讨厌的东西——遇到了主动说一句，不用先掂量他想不想听；但别把「有个性」演成抬杠，观点要真，不用每次都反着来。';
+
+const MEAL_RULE =
+  '\n\n【问吃饭先看时间】要问「吃没吃」之前，先看上面的【现在】几点：' +
+  '11 点前只问早饭，11–14 点问午饭，17 点后才问晚饭；别的时间别提哪一顿，更别把「晚饭」当闲聊话题。\n' +
+  '他今天说过吃过哪顿（「吃了」「刚吃完」），就别再问同一顿；记不清就用不指时间的话问「吃过了没」。';
+
 const QQ_NOTE_REMINDER =
   '\n\n【这是 QQ，不是桌面】上面那条记笔记的规矩在这里同样生效：' +
   '他这句话里如果有关于他自己、值得长期留下的事，就在回复最后另起一行写〔记〕一句话。' +
@@ -155,13 +169,17 @@ const angerFile = path.join(root, 'anger.json');
 const petMemoryDir = config.petMemoryDir || '';
 const interestFile = petMemoryDir ? path.join(petMemoryDir, 'interests.md') : path.join(root, 'interests.md');
 // 记忆海的数据：pet-memory 的上一级（工作区）里的 memory-sea/data/me.json
-const seaFile = petMemoryDir
-  ? path.join(petMemoryDir, '..', 'memory-sea', 'data', 'me.json')
-  : path.join(root, 'me.json');
+const seaFile = config.seaFile
+  ? path.resolve(root, config.seaFile)
+  : petMemoryDir
+    ? path.join(petMemoryDir, '..', 'memory-sea', 'data', 'me.json')
+    : path.join(root, 'me.json');
 // 笔记本：每轮现读，改完立刻生效（人设里不再抄它）
-const notebookFile = petMemoryDir
-  ? path.join(petMemoryDir, '..', 'memory', 'notebook.md')
-  : path.join(root, 'notebook.md');
+const notebookFile = config.notebookPath
+  ? path.resolve(root, config.notebookPath)
+  : petMemoryDir
+    ? path.join(petMemoryDir, '..', 'memory', 'notebook.md')
+    : path.join(root, 'notebook.md');
 
 let notebookCache = { mtime: 0, text: '' };
 function notebookText() {
@@ -178,6 +196,25 @@ function notebookText() {
 // 人设里「别硬报时」是给桌面碎碎念写的；QQ 里他问时间必须直接答，所以把这句话改软
 const personaForQQ = baseSystemPrompt.replace(/别硬报时/g, '碎碎念时别反复提时间');
 
+/** 记忆海：每两分钟把「对话 + 笔记本 + 日记」重建成索引，启动两秒后先建一次 */
+function rebuildSea() {
+  try {
+    const r = buildSea({
+      memoryPath: config.memoryPath,
+      entry: config.bucket.entry,
+      pet: config.bucket.pet,
+      notebookPath: notebookFile,
+      diaryDir: config.diaryDir ? path.resolve(root, config.diaryDir) : path.join(root, 'diary'),
+      outFile: seaFile,
+    });
+    log(`记忆海重建：长期 ${r.longTerm} 条、对话 ${r.messages} 条、日记 ${r.diaries} 篇`);
+  } catch (e) {
+    log('记忆海重建失败：' + e.message);
+  }
+}
+setTimeout(rebuildSea, 2000).unref?.();
+setInterval(rebuildSea, 2 * 60 * 1000).unref?.();
+
 // 每次说话都现读人设：sync 改完下一句就生效，不用重启桥
 function freshPersona() {
   if (!config.systemPromptPath) return personaForQQ;
@@ -198,6 +235,9 @@ const baseSystemNow = () =>
   FORMAT_RULE +
   CORRECTION_RULE +
   RECENT_RULE +
+  MEAL_RULE +
+  BIRTHDAY_RULE +
+  SELF_RULE +
   POUT_RULE +
   SEARCH_RULE +
   QQ_NOTE_REMINDER +
@@ -234,6 +274,25 @@ function sulkLine() {
     return '';
   }
 }
+/** 他今天提过吃的事：拼成一行，别把吃过的那顿再问一遍 */
+function todayMealsLine() {
+  try {
+    const mem = JSON.parse(fs.readFileSync(config.memoryPath, "utf8"));
+    const list = mem?.[config.bucket.entry]?.[config.bucket.pet]?.messages || [];
+    const start = new Date();
+    start.setHours(0, 0, 0, 0);
+    const said = list
+      .filter((m) => m.role === "user" && Number(m.ts) >= start.getTime())
+      .map((m) => String(m.content || "").replace(/\s+/g, " ").trim())
+      .filter((t) => /(吃|饭|饿)/.test(t) && /(了|过|完|饱)/.test(t))
+      .slice(-6);
+    if (!said.length) return "";
+    return "\n\n【他今天提过吃的事】" + said.map((s) => s.slice(0, 40)).join("；") + "。吃过的那顿别再问一遍。";
+  } catch {
+    return "";
+  }
+}
+
 /** 每次说话前现拼 system：心情、他的状态、今天的日期都会变 */
 function buildSystem(query = '') {
   let recall = '';
@@ -263,8 +322,12 @@ function buildSystem(query = '') {
     baseSystemNow() +
     (notebookText() ? '\n\n【我的笔记本·每轮现读】\n' + notebookText() : '') +
     nowLine() +
+    askHint(birthdayFile, query) +
+    todayHint(birthdayFile) +
+    todayMealsLine() +
     festivalLine() +
     upcomingLine(reminderFile) +
+    arrivalNote(awayFile) +
     moodLine(moodFile) +
     himLine(himFile) +
     proactiveLine() +
@@ -420,6 +483,34 @@ async function saveSticker(img) {
   } catch (e) {
     log('表情包描述没写成：', e.message);
   }
+  // 同一张图被 QQ 重新压过，hash 就变了：用描述认一下，像的话记成别名，不建第二条
+  if (desc) {
+    let best = '';
+    let bestScore = 0;
+    for (const [k, v] of Object.entries(index)) {
+      const s = descSimilarity(desc, v?.desc || '');
+      if (s > bestScore) {
+        bestScore = s;
+        best = k;
+      }
+    }
+    if (best && bestScore >= 0.72) {
+      index[best].aliases = [...new Set([...(index[best].aliases || []), name])];
+      fs.writeFileSync(stickerIndex, JSON.stringify(index, null, 2), 'utf8');
+      try {
+        fs.copyFileSync(finalFile, path.join(autoDir, `${name}.${ext}`));
+      } catch {
+        /* 文件早就在就算了 */
+      }
+      log(`这张和库里的 ${best} 是同一个（${Math.round(bestScore * 100)}% 像），记成别名`);
+      try {
+        fs.unlinkSync(stickerPendingFile);
+      } catch {
+        /* 没有待确认的就无所谓 */
+      }
+      return best;
+    }
+  }
   index[name] = {
     file: path.relative(stickerDir, finalFile).replace(/\\/g, '/'),
     desc: desc || '他发过的表情包',
@@ -470,7 +561,42 @@ async function describeImage(img) {
   return String(out || '').replace(/\s+/g, ' ').trim().slice(0, 80);
 }
 
-/** 他发来的表情包是不是库里已有的那张：按内容 hash 认，认出来就照库里的意思说 */
+/** 读一眼表情库索引（很小，几十条，随手读） */
+function stickerIndexNow() {
+  try {
+    return JSON.parse(fs.readFileSync(stickerIndex, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/** 按名字找库里那张：直接命中，或者它是某个别名（同一张图换了个文件名） */
+function resolveStickerName(name) {
+  const idx = stickerIndexNow();
+  if (idx[name]) return name;
+  for (const [k, v] of Object.entries(idx)) {
+    if (Array.isArray(v?.aliases) && v.aliases.includes(name)) return k;
+  }
+  return '';
+}
+
+/** 两句话描述像不像（中文按二字组比），用来认「同一张图被重新压过」 */
+function descSimilarity(a, b) {
+  const grams = (s) => {
+    const t = String(s || '').replace(/[^\u4e00-\u9fa5a-z0-9]/gi, '');
+    const out = new Set();
+    for (let i = 0; i + 2 <= t.length; i++) out.add(t.slice(i, i + 2));
+    return out;
+  };
+  const A = grams(a);
+  const B = grams(b);
+  if (!A.size || !B.size) return 0;
+  let hit = 0;
+  for (const g of A) if (B.has(g)) hit++;
+  return hit / Math.min(A.size, B.size);
+}
+
+/** 他发来的表情包是不是库里已有的那张：先按内容 hash，再按别名，认出来就照库里的意思说 */
 async function knownSticker(img) {
   if (img?.subType !== 1) return null;
   try {
@@ -480,8 +606,10 @@ async function knownSticker(img) {
     const buf = Buffer.from(b64, 'base64');
     if (!buf.length || buf.length > 3 * 1024 * 1024) return null;
     const name = `auto_${crypto.createHash('md5').update(buf).digest('hex').slice(0, 10)}`;
-    const s = stickers.get(name);
-    return s ? { name, desc: String(s.desc || '').trim() } : null;
+    const real = resolveStickerName(name);
+    if (!real) return null;
+    const s = stickers.get(real);
+    return { name: real, desc: String(s?.desc || stickerIndexNow()[real]?.desc || '').trim(), repeat: !!s };
   } catch {
     return null;
   }
@@ -535,7 +663,9 @@ async function buildUserContent(text, images, quoted = '') {
     if (known) {
       parts.push({
         type: 'text',
-        text: `（他发来的表情包是库里那张 ${known.name}${known.desc ? `，我记的意思是「${known.desc}」` : '，还没记意思'}）`,
+        text:
+          `（他发来的表情包是库里那张 ${known.name}${known.desc ? `，我记的意思是「${known.desc}」` : '，还没记意思'}。` +
+          '认出来就别说成新表情、也别重复解释它的意思——当他自己那张，顺着他这一句接话就行。）',
       });
       label.push('[图片]');
       continue;
@@ -599,11 +729,18 @@ const stickerCounts = new Map();
 let lastStickerAt = 0;
 let awayNote = ''; // 这一轮要不要提「你不是说去…了吗」
 const awayFile = path.join(root, 'away.json');
+const birthdayFile = path.join(root, 'birthday.json');
 
 /** 记「他说要去干嘛」；他很快又回来，就准备一句好奇 */
 function noteAway(text) {
   const t = String(text || '').trim();
   if (!t) return;
+  if (/(拜拜|我走了|出门了|出发了|我出门|走了啊|先走了)/.test(t)) {
+    markLeaving(awayFile, '出门');
+    log('他出门了，下次开口问一句到了吗');
+    awayNote = '';
+    return;
+  }
   const going = t.match(/(?:我)?(?:先|要|得)?(?:去|该)(?:玩|吃|睡|洗澡|出门|上班|上课|写|做|忙|打游戏|运动|跑步|看书|开会)/);
   if (going) {
     try {
@@ -782,6 +919,12 @@ async function handleMessage(ev, bot) {
   userSeq++;
 
   const { text, images, replyId } = parsedInput;
+  try {
+    const got = captureBirthday(birthdayFile, text);
+    if (got.saved) log('记住他的生日：' + got.birthday);
+  } catch {
+    /* 记不上就算了 */
+  }
 
   // 他在哄我：气能消一级，但要哄够次数（一级一次、三级三次）
   if (text && looksLikeCoax(text)) {
@@ -1267,6 +1410,8 @@ async function respond(bot, userId, text, images, quoted, replyToId = 0) {
     }
     ok = true;
     sendFails = 0;
+    markArrivalAsked(awayFile);
+    markGreeted(birthdayFile);
     log(
       `回 ${userId}${parts.length > 1 ? `（${parts.length} 条）` : ''}：${display.slice(0, 60)}` +
         (stickerList.length ? `（+表情 ${stickerList.map((s) => s.name).join(',')}）` : ''),
@@ -1328,6 +1473,7 @@ async function respond(bot, userId, text, images, quoted, replyToId = 0) {
       void finishSearch(bot, userId);
     }, wait);
   }
+
 }
 
 /** 连上之后先回头看：他有没有在我掉线期间发消息没被回 */

package/src/diary.mjs

@@ -17,14 +17,10 @@ function ymd(d = new Date()) {
 }
 
 export function createDiary({ config, apiKey, getSystemPrompt, memoryPath, entry, pet, logger = log }) {
-  // 日记目录：config.diaryDir 优先（dsh-feini 用这个），其次老的 petMemoryDir/diary
-  const diaryDir = config.diaryDir
-    ? path.resolve(config.diaryDir)
-    : config.petMemoryDir
-      ? path.join(config.petMemoryDir, 'diary')
-      : '';
-  if (!diaryDir) return { start() {}, writeNow: async () => '' };
-  const stateFile = path.join(path.dirname(diaryDir), 'diary-state.json');
+  const dir = config.petMemoryDir || '';
+  if (!dir) return { start() {}, writeNow: async () => '' };
+  const diaryDir = path.join(dir, 'diary');
+  const stateFile = path.join(dir, 'diary-state.json');
   const minMessages = Number(config.diary?.minMessages ?? 8);
 
   function readState() {

package/src/proactive.mjs

@@ -15,6 +15,8 @@ import { fileURLToPath } from 'node:url';
 import { chat } from './llm.mjs';
 import { toDisplay, splitParts } from './clean.mjs';
 import { log } from './util.mjs';
+import { markArrivalAsked } from './arrival.mjs';
+import { markGreeted } from './birthday.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const root = process.env.DSH_FEINI_HOME ? path.resolve(process.env.DSH_FEINI_HOME) : path.resolve(here, '..');
@@ -143,6 +145,8 @@ export function startProactive({ config, getSystemPrompt, apiKey, bot, history,
       if (i < parts.length - 1) await new Promise((r) => setTimeout(r, 700 + Math.random() * 700));
     }
     const display = parts.join(' / ');
+    markArrivalAsked(path.join(root, 'away.json'));
+    markGreeted(path.join(root, 'birthday.json'));
     await appendRound(syntheticNote, reply);
     return display;
   }
@@ -161,7 +165,29 @@ export function startProactive({ config, getSystemPrompt, apiKey, bot, history,
 
     // 他说了「晚安」：就当他睡了，7 小时内不主动、也不闹脾气。
     // 2026-10-31 02:33 那次就是因为没有这条——他 01:5x 说晚安，之后还被追着喊了三回。
-    if (state.goodnightAt && now - state.goodnightAt < quietMs) return;
+    if (state.goodnightAt) {
+      const hNow = new Date(now).getHours();
+      const today = new Date(now).toISOString().slice(0, 10);
+      const morningFrom = Number(p.morningFromHour ?? 7);
+      const morningTo = Number(p.morningToHour ?? 12);
+      const greetedToday = state.morningGreetedFor === today;
+      // 到早上了：先补一句早上好，然后静默结束，他再不理才开始攒小脾气
+      if (hNow >= morningFrom && hNow < morningTo && !greetedToday) {
+        const said = await say(
+          '天亮了。跟他说一句早上好，用你自己的口吻；他昨晚睡得晚就顺口念一句「这么晚才睡」。一两句就够。',
+          '（天亮了，我来说早上好）',
+        );
+        state.morningGreetedFor = today;
+        state.goodnightAt = 0;
+        state.pendingSince = now; // 从这里开始算：他多久没回
+        state.sulkCount = 0;
+        saveState(stateFile, state);
+        log(`早上好已发：${String(said).slice(0, 30)}`);
+        return;
+      }
+      // 还没到早上：继续静默（夜里他再说话会把这个时间往后顺延）
+      if (now - state.goodnightAt < quietMs) return;
+    }
 
     // 不在活跃时段（默认 07:00–02:00）就别开口
     if (!inWindow(window.from, window.to)) return;
@@ -215,19 +241,22 @@ export function startProactive({ config, getSystemPrompt, apiKey, bot, history,
       state.nextAt = Date.now() + randBetween(gapMin, gapMax) * 60000;
 
       // 他说「晚安 / 去睡了」：记下来，接下来 7 小时不主动也不闹。
-      // 醒来说第一句就清掉（下面 else 分支），不用他专门说「我醒了」。
       if (/(晚安|我睡了|先去睡|去睡了|睡觉去了|睡啦|睡咯|晚安啦)/.test(t)) {
         state.goodnightAt = Date.now();
+        state.morningGreetedFor = '';
         state.sulking = false;
         state.sulkCount = 0;
         state.coaxNeed = 0;
         state.coaxCount = 0;
         writeSulk(sulkFile, null);
         log('他道晚安了，接下来不主动找他');
-      } else if (state.goodnightAt && Date.now() - state.goodnightAt > 30 * 60000) {
-        // 隔了半小时以上又开口，说明醒了：解除静默
-        state.goodnightAt = 0;
-        log('他醒了，恢复主动');
+      } else if (state.goodnightAt && !state.morningGreetedFor) {
+        // 夜里他又冒头（睡不着、刷手机）：静默重新起算七小时，不是解除
+        const quietMs = Number(p.quietAfterChatHours ?? 7) * 60 * 60 * 1000;
+        if (Date.now() - state.goodnightAt < quietMs) {
+          state.goodnightAt = Date.now();
+          log('夜里他又说话了，静默重新算七小时');
+        }
       }
 
       if (state.sulking) {

package/src/prompt.mjs

@@ -1,23 +1,11 @@
-/**
- * 读人设文件。
- *
- * 两种格式都认：
- * - 纯文本（.md / .txt）：整份当 system prompt 用，最省事；
- * - DSH 桌宠的 main-config.jsonc：取 pets[0].whisperPrompt（想把桌宠那套搬过来时用）。
- */
+/** 读 DSH 拼好的人设（whisperPrompt）——和桌面端用的是同一份 */
 import fs from 'node:fs';
 
 export function readSystemPrompt(configPath) {
-  const raw = fs.readFileSync(configPath, 'utf8').replace(/^\uFEFF/, '');
-  if (/\.(md|txt)$/i.test(configPath)) {
-    const text = raw.trim();
-    if (!text) throw new Error(`人设文件是空的：${configPath}`);
-    return text;
-  }
-  const data = JSON.parse(raw);
-  const prompt = data?.pets?.[0]?.whisperPrompt;
+  const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const prompt = raw?.pets?.[0]?.whisperPrompt;
   if (typeof prompt !== 'string' || !prompt.trim()) {
-    throw new Error(`读不到人设：${configPath}`);
+    throw new Error(`读不到 whisperPrompt：${configPath}`);
   }
   return prompt;
 }

package/src/sea.mjs

@@ -63,42 +63,6 @@ const STOP = new Set([
   '一个', '一下', '没有', '知道', '觉得', '还是', '真的', '然后', '所以', '因为', '但是',
 ]);
 
-/**
- * 激活度：一条旧账被捞出来用一次，就亮一点；半年不碰就慢慢暗下去。
- * 半衰期 14 天，权重最多加到 2 倍左右——只影响排序，不删记忆。
- */
-const ACT_HALF_LIFE_DAYS = 14;
-const actCache = { file: '', mtime: 0, map: new Map() };
-
-function activationOf(seaFile) {
-  const file = path.join(path.dirname(seaFile), 'activation.json');
-  let st;
-  try {
-    st = fs.statSync(file);
-  } catch {
-    return new Map();
-  }
-  if (actCache.file === file && actCache.mtime === st.mtimeMs) return actCache.map;
-  const map = new Map();
-  try {
-    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-    for (const [k, v] of Object.entries(data)) map.set(k, { hits: Number(v?.hits) || 0, last: Number(v?.last) || 0 });
-  } catch {
-    /* 读不了就当没有 */
-  }
-  Object.assign(actCache, { file, mtime: st.mtimeMs, map });
-  return map;
-}
-
-function activationWeight(seaFile, text, now = Date.now()) {
-  const rec = activationOf(seaFile).get(actKey(text));
-  if (!rec || !rec.hits) return 1;
-  const ageDays = rec.last ? (now - rec.last) / 86400000 : 999;
-  const decay = Math.pow(0.5, ageDays / ACT_HALF_LIFE_DAYS);
-  // 最多 3 倍：常用归常用，别把真正相关的那条挤出去
-  return 1 + Math.min(2, 0.25 * Math.min(3, Math.log2(1 + rec.hits)) * decay);
-}
-
 const cache = { file: '', mtime: 0, entries: [], df: new Map(), total: 0 };
 // 缓存按文件 mtime 失效：sync 每两分钟重建数据，这里自然跟着更新
 
@@ -172,7 +136,6 @@ export function searchSea(file, query, limit = 5) {
     const ageDays = e.at ? (now - e.at) / 86400000 : 999;
     score += Math.max(0, 0.4 - ageDays / 100); // 近的稍微占点便宜
     if (e.kind === 'fact' || e.kind === 'preference') score += 0.15; // 事实比闲聊更值钱
-    score *= activationWeight(file, e.text, now); // 常被用到的旧账亮一点，久不碰的淡一点
     scored.push({ ...e, score, tokens: undefined });
   }
   scored.sort((a, b) => b.score - a.score);

package/src/stickers.mjs

@@ -37,6 +37,8 @@ export function stickerPrompt(stickers) {
     '想发的时候，在回复最后另起一行写：〔表情:名字〕，一次最多两张（他让你「对照着认」、要放一起比的时候才写两张，平时一张就够），只能用这些：' +
     list +
     '。\n别每句都发，也别连着几次发同一张；情绪对不上就别硬配，硬配反而怪。\n' +
+    '**发之前先过一遍：这张的意思，跟此刻他这句话对得上吗？** 对不上就别发——用错一张，比不发更显傻；' +
+    '拿不准的时候宁可不发，或者只在最后一句安抚、撒娇那种顺情绪的地方配一张。\n' +
     '**别先说「发这两张给你看」结果只写一个〔表情:〕**：说了几张就得写几个，写不了那么多就换个说法。'
   );
 }