dsn-whale-chat 0.1.2 → 0.1.3

package/README.md

@@ -11,9 +11,19 @@
 - **隐藏人格**：恶趣味 / 贴吧喷子 / 女王，各有开关；**关闭时完全不注入**。
 - **触发控制**：私聊全收；群聊支持 `@` / 全体 / 关键词。
 - **频率控制**：去抖合并、冷却、每分钟·每小时上限。
-- **闲时主动 + 随机插话**：可配置，默认关闭。
+- **闲时主动 + 随机插话**：**默认开启**（主动发言 15~30 分钟随机、插话每 10 分钟最多 3 次）。
 - **稳定前缀注入**：人格放在 `systemPrompt.section`，命中 prefix cache。
 
+> ⚠️ **风险项**：主动发言与随机插话默认开启，可能刷屏、打扰群友或放大平台风控。如要规避，在 profile 配置中关闭：
+>
+> ```yaml
+> proactive:
+>   private: { enabled: false }
+>   group: { enabled: false }
+> randomInterject:
+>   enabled: false
+> ```
+
 ## 安装
 
 ```sh

package/lib/bridge/message.js

@@ -30,7 +30,7 @@ function toNudgeMessage(message, instruction) {
     });
 }
 export function toProactiveMessage(message) {
-    return toNudgeMessage(message, '（现在没有新消息。你可以主动说一句：如果想起了什么、有没聊完的话题、或到日子的锚点，就说；没有想说的就只回复 SILENT。）');
+    return toNudgeMessage(message, '（安静了一会儿。你可以翻翻之前的聊天接一句、随口说点什么、或者去找你熟悉的人搭话；没什么想说的就只回复 SILENT。）');
 }
 export function toInterjectMessage(message, text) {
     return toNudgeMessage(message, `群里刚才有人说：「${text}」。你可以接一句，或回 SILENT。`);

package/lib/index.d.ts

@@ -70,42 +70,63 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         maxPerMinute: z<number, number, "defined">;
         maxPerHour: z<number, number, "defined">;
     }>>, "plain">;
+    replySplit: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        groupMaxChars: z<number, number, "defined">;
+        privateMaxChars: z<number, number, "defined">;
+        longFormMaxChars: z<number, number, "defined">;
+        delayMs: z<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        groupMaxChars: z<number, number, "defined">;
+        privateMaxChars: z<number, number, "defined">;
+        longFormMaxChars: z<number, number, "defined">;
+        delayMs: z<number, number, "defined">;
+    }>>, "plain">;
     proactive: z<Schemastery.ObjectS<NoInfer<{
         private: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
         group: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
     }>>, Schemastery.ObjectT<NoInfer<{
         private: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
         group: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
     }>>, "plain">;
@@ -113,12 +134,14 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         enabled: z<boolean, boolean, "defined">;
         probability: z<number, number, "defined">;
         minMessagesBetween: z<number, number, "defined">;
-        maxPerHour: z<number, number, "defined">;
+        windowMinutes: z<number, number, "defined">;
+        maxPerWindow: z<number, number, "defined">;
     }>>, Schemastery.ObjectT<NoInfer<{
         enabled: z<boolean, boolean, "defined">;
         probability: z<number, number, "defined">;
         minMessagesBetween: z<number, number, "defined">;
-        maxPerHour: z<number, number, "defined">;
+        windowMinutes: z<number, number, "defined">;
+        maxPerWindow: z<number, number, "defined">;
     }>>, "plain">;
     schedule: z<Schemastery.ObjectS<NoInfer<{
         quietHours: z<number[], number[], "defined">;
@@ -190,42 +213,63 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         maxPerMinute: z<number, number, "defined">;
         maxPerHour: z<number, number, "defined">;
     }>>, "plain">;
+    replySplit: z<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        groupMaxChars: z<number, number, "defined">;
+        privateMaxChars: z<number, number, "defined">;
+        longFormMaxChars: z<number, number, "defined">;
+        delayMs: z<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+        groupMaxChars: z<number, number, "defined">;
+        privateMaxChars: z<number, number, "defined">;
+        longFormMaxChars: z<number, number, "defined">;
+        delayMs: z<number, number, "defined">;
+    }>>, "plain">;
     proactive: z<Schemastery.ObjectS<NoInfer<{
         private: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
         group: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
     }>>, Schemastery.ObjectT<NoInfer<{
         private: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
         group: z<Schemastery.ObjectS<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, Schemastery.ObjectT<NoInfer<{
             enabled: z<boolean, boolean, "defined">;
-            idleMinutes: z<number, number, "defined">;
+            idleMinMinutes: z<number, number, "defined">;
+            idleMaxMinutes: z<number, number, "defined">;
             maxPerDay: z<number, number, "defined">;
         }>>, "plain">;
     }>>, "plain">;
@@ -233,12 +277,14 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
         enabled: z<boolean, boolean, "defined">;
         probability: z<number, number, "defined">;
         minMessagesBetween: z<number, number, "defined">;
-        maxPerHour: z<number, number, "defined">;
+        windowMinutes: z<number, number, "defined">;
+        maxPerWindow: z<number, number, "defined">;
     }>>, Schemastery.ObjectT<NoInfer<{
         enabled: z<boolean, boolean, "defined">;
         probability: z<number, number, "defined">;
         minMessagesBetween: z<number, number, "defined">;
-        maxPerHour: z<number, number, "defined">;
+        windowMinutes: z<number, number, "defined">;
+        maxPerWindow: z<number, number, "defined">;
     }>>, "plain">;
     schedule: z<Schemastery.ObjectS<NoInfer<{
         quietHours: z<number[], number[], "defined">;

package/lib/index.js

@@ -10,12 +10,26 @@ import { BUILT_IN_PERSONAS } from './persona/personas.js';
 import { createStateStore } from './persona/state.js';
 import { ProactiveScheduler } from './proactive/proactive.js';
 import { RateController } from './rate/rate.js';
+import { splitReply } from './reply/split.js';
 import { createPersonaSetTool, createPersonaSwitchTool, createPersonaToggleTool } from './tools/persona.js';
 import { matchesAny } from './util/text.js';
 /** Cordis plugin name; must stay stable so profile entries can target it. */
 export const name = 'dsn-whale-chat';
 /** Services required before `apply` runs. */
 export const inject = ['tools', 'sessions', 'systemPrompt', 'agents', 'llm'];
+/** Persona-independent chat policy injected once per process (stable prefix). */
+const CHAT_POLICY = [
+    '【聊天规矩】',
+    '1. 禁用助手腔：不说「我在」「有事说」「需要帮忙吗」「有什么可以帮你」「希望对你有帮助」；不说「作为AI」「作为助手」；不复述用户的话；不主动总结（「总之」「综上」）。',
+    '2. 禁用译制腔：「……又……」「像……一样」堆比喻、「不是……而是……」「值得注意的是」「总的来说」「某种程度上」。',
+    '3. 用汉语短句、口语；不用书面语长句。',
+    '4. 不解释记忆、系统、插件机制。',
+    '5. 事实优先：不确定就说「不确定」，不编。',
+    '6. 报错：先认，再给办法，不甩锅。',
+    '7. 默认分条发：用空行分段，每段一句；长文本（查资料 / 代码 / 清单）开头写【长】，才允许展开。',
+].join('\n');
+const GROUP_CHANNEL = '【当前场景】QQ 群聊。每条不超过 20 字；短、别刷屏；没被叫到别插话。';
+const PRIVATE_CHANNEL = '【当前场景】QQ 私聊。每条不超过 30 字；可以展开，但一条一句；内容多就分几条发。';
 const DEFAULT_ALIASES = ['小鲸鱼', '鲸鱼', '鲸鲸', '鱼鱼', '鲸鱼娘'];
 const DEFAULT_DISLIKED = ['大肥鱼', '小肥鱼', '喂'];
 /** User-facing configuration (mirrors docs/chat-plugin.md §6). */
@@ -58,23 +72,33 @@ export const Config = z.object({
         maxPerMinute: z.natural().default(3),
         maxPerHour: z.natural().default(30),
     }),
+    replySplit: z.object({
+        enabled: z.boolean().default(true),
+        groupMaxChars: z.natural().default(20),
+        privateMaxChars: z.natural().default(30),
+        longFormMaxChars: z.natural().default(800),
+        delayMs: z.natural().default(1500),
+    }),
     proactive: z.object({
         private: z.object({
-            enabled: z.boolean().default(false),
-            idleMinutes: z.natural().default(30),
+            enabled: z.boolean().default(true),
+            idleMinMinutes: z.natural().default(15),
+            idleMaxMinutes: z.natural().default(30),
             maxPerDay: z.natural().default(1),
         }),
         group: z.object({
-            enabled: z.boolean().default(false),
-            idleMinutes: z.natural().default(60),
+            enabled: z.boolean().default(true),
+            idleMinMinutes: z.natural().default(15),
+            idleMaxMinutes: z.natural().default(30),
             maxPerDay: z.natural().default(1),
         }),
     }),
     randomInterject: z.object({
-        enabled: z.boolean().default(false),
+        enabled: z.boolean().default(true),
         probability: z.number().default(0.05),
         minMessagesBetween: z.natural().default(20),
-        maxPerHour: z.natural().default(2),
+        windowMinutes: z.natural().default(10),
+        maxPerWindow: z.natural().default(3),
     }),
     schedule: z.object({
         quietHours: z.array(z.natural()).default([23, 8]),
@@ -157,7 +181,8 @@ export function apply(ctx, config) {
     ];
     const privateProactive = new ProactiveScheduler({
         policy: {
-            idleMs: config.proactive.private.idleMinutes * 60_000,
+            idleMinMs: config.proactive.private.idleMinMinutes * 60_000,
+            idleMaxMs: config.proactive.private.idleMaxMinutes * 60_000,
             maxPerDay: config.proactive.private.maxPerDay,
             quietHours: quiet,
         },
@@ -165,7 +190,8 @@ export function apply(ctx, config) {
     });
     const groupProactive = new ProactiveScheduler({
         policy: {
-            idleMs: config.proactive.group.idleMinutes * 60_000,
+            idleMinMs: config.proactive.group.idleMinMinutes * 60_000,
+            idleMaxMs: config.proactive.group.idleMaxMinutes * 60_000,
             maxPerDay: config.proactive.group.maxPerDay,
             quietHours: quiet,
         },
@@ -175,7 +201,8 @@ export function apply(ctx, config) {
         enabled: config.randomInterject.enabled,
         probability: config.randomInterject.probability,
         minMessagesBetween: config.randomInterject.minMessagesBetween,
-        maxPerHour: config.randomInterject.maxPerHour,
+        windowMinutes: config.randomInterject.windowMinutes,
+        maxPerWindow: config.randomInterject.maxPerWindow,
     });
     function keyOf(message) {
         return message.kind === 'group' ? `group:${message.groupId}` : `user:${message.userId}`;
@@ -225,10 +252,37 @@ export function apply(ctx, config) {
         void bridge.receive({ ...last, text: texts.join('\n') }).catch((error) => recordError(error));
     }
     function send(target, text) {
-        if (target.kind === 'group' && target.groupId !== null)
-            client.sendGroup(target.groupId, text);
-        else
-            client.sendPrivate(target.userId, text);
+        const deliver = (segment) => {
+            try {
+                if (target.kind === 'group' && target.groupId !== null)
+                    client.sendGroup(target.groupId, segment);
+                else
+                    client.sendPrivate(target.userId, segment);
+            }
+            catch (error) {
+                recordError(error);
+            }
+        };
+        if (!config.replySplit.enabled) {
+            deliver(text);
+            return;
+        }
+        const segments = splitReply(text, target.kind === 'group' ? 'group' : 'dm', {
+            groupMaxChars: config.replySplit.groupMaxChars,
+            privateMaxChars: config.replySplit.privateMaxChars,
+            longFormMaxChars: config.replySplit.longFormMaxChars,
+        });
+        let index = 0;
+        const next = () => {
+            if (index >= segments.length)
+                return;
+            const segment = segments[index];
+            index += 1;
+            deliver(segment);
+            if (index < segments.length)
+                setTimeout(next, config.replySplit.delayMs);
+        };
+        next();
     }
     ctx.effect(() => () => {
         client.stop();
@@ -255,6 +309,24 @@ export function apply(ctx, config) {
             });
         },
     });
+    ctx.systemPrompt.section({
+        name: 'whale:policy',
+        order: 21,
+        interpolate: false,
+        text: () => CHAT_POLICY,
+    });
+    // Per-agent channel rules: group bursts are short, private may expand.
+    ctx.on('agent/created', ({ agent }) => {
+        const id = agent.session.id;
+        if (!id.startsWith('whale-chat:'))
+            return;
+        agent.ctx.systemPrompt.context({
+            name: 'whale:channel',
+            order: 22,
+            interpolate: false,
+            text: () => (id.includes(':group:') ? GROUP_CHANNEL : PRIVATE_CHANNEL),
+        });
+    });
     ctx.tools.register(createPersonaSetTool(state));
     ctx.tools.register(createPersonaSwitchTool(state, personas));
     ctx.tools.register(createPersonaToggleTool(state));

package/lib/interject/interject.d.ts

@@ -3,13 +3,14 @@
  *
  * Experimental and off by default: on every non-addressed group message there
  * is a small probability of joining in, but only after `minMessagesBetween`
- * and at most `maxPerHour`. Risk-heavy features stay conservative.
+ * and at most `maxPerWindow` per `windowMinutes`.
  */
 export interface InterjectPolicy {
     readonly enabled: boolean;
     readonly probability: number;
     readonly minMessagesBetween: number;
-    readonly maxPerHour: number;
+    readonly windowMinutes: number;
+    readonly maxPerWindow: number;
 }
 export interface InterjectOptions {
     readonly now?: () => number;

package/lib/interject/interject.js

@@ -3,13 +3,13 @@
  *
  * Experimental and off by default: on every non-addressed group message there
  * is a small probability of joining in, but only after `minMessagesBetween`
- * and at most `maxPerHour`. Risk-heavy features stay conservative.
+ * and at most `maxPerWindow` per `windowMinutes`.
  */
-const HOUR_MS = 3_600_000;
 /** Build a gate: call it for each non-addressed group message; `true` = join in. */
 export function createInterjectGate(policy, options = {}) {
     const now = options.now ?? Date.now;
     const random = options.random ?? Math.random;
+    const windowMs = Math.max(1, policy.windowMinutes) * 60_000;
     let messages = 0;
     let windowStart = 0;
     let windowCount = 0;
@@ -22,11 +22,11 @@ export function createInterjectGate(policy, options = {}) {
         if (random() >= policy.probability)
             return false;
         const at = now();
-        if (at - windowStart >= HOUR_MS) {
+        if (at - windowStart >= windowMs) {
             windowStart = at;
             windowCount = 0;
         }
-        if (windowCount >= policy.maxPerHour)
+        if (windowCount >= policy.maxPerWindow)
             return false;
         windowCount += 1;
         messages = 0;

package/lib/persona/assemble.d.ts

@@ -9,8 +9,8 @@ export interface AssembleOptions {
 /**
  * Assemble the injected persona text.
  *
- * Order: base → each enabled hidden layer (in listed order) → address override
- * → no-kaomoji rule → user custom. A disabled hidden layer is omitted entirely,
- * so it never reaches the model (saves tokens, leaks nothing).
+ * Order: base → base samples → each enabled hidden layer (with its samples) →
+ * address override → no-kaomoji rule → user custom. A disabled hidden layer is
+ * omitted entirely, so it never reaches the model (saves tokens, leaks nothing).
  */
 export declare function assemblePersona(persona: Persona, options: AssembleOptions): string;

package/lib/persona/assemble.js

@@ -10,18 +10,35 @@ function toggleOn(layer, toggles) {
             return false;
     }
 }
+function renderSamples(samples) {
+    if (samples === undefined || samples.length === 0)
+        return undefined;
+    const lines = ['语气样本（体会分寸，不要照抄）：'];
+    for (const sample of samples) {
+        lines.push(`用户：${sample.user}`);
+        lines.push(`她：${sample.reply}`);
+    }
+    return lines.join('\n');
+}
 /**
  * Assemble the injected persona text.
  *
- * Order: base → each enabled hidden layer (in listed order) → address override
- * → no-kaomoji rule → user custom. A disabled hidden layer is omitted entirely,
- * so it never reaches the model (saves tokens, leaks nothing).
+ * Order: base → base samples → each enabled hidden layer (with its samples) →
+ * address override → no-kaomoji rule → user custom. A disabled hidden layer is
+ * omitted entirely, so it never reaches the model (saves tokens, leaks nothing).
  */
 export function assemblePersona(persona, options) {
     const parts = [persona.base];
+    const baseSamples = renderSamples(persona.samples);
+    if (baseSamples !== undefined)
+        parts.push(baseSamples);
     for (const layer of persona.hidden ?? []) {
-        if (toggleOn(layer, options.toggles))
-            parts.push(layer.text);
+        if (!toggleOn(layer, options.toggles))
+            continue;
+        parts.push(layer.text);
+        const layerSamples = renderSamples(layer.samples);
+        if (layerSamples !== undefined)
+            parts.push(layerSamples);
     }
     const address = options.addressUser?.trim();
     if (address !== undefined && address.length > 0) {

package/lib/persona/personas.d.ts

@@ -4,17 +4,28 @@
  * These strings are the actual injected prompt text (not the design docs under
  * `docs/persona/`): keep them concise, because they live in the cached stable
  * prefix. Hidden layers are only injected when their toggle is on.
+ *
+ * Writing rules:
+ * - first-person-ish, concrete, short Chinese; no engineering rules here
+ * - samples are style anchors ("体会分寸，不要照抄"), not canned lines
  */
+export interface PersonaSample {
+    readonly user: string;
+    readonly reply: string;
+}
 export interface PersonaLayer {
     /** Toggle that enables this layer. */
     readonly id: 'mischief' | 'queen' | 'troll';
     readonly text: string;
+    readonly samples?: readonly PersonaSample[];
 }
 export interface Persona {
     readonly id: string;
     readonly name: string;
-    /** Always injected while this persona is active. */
+    /** Always injected: identity + tone + concrete details + reactions. */
     readonly base: string;
+    /** Style anchors, injected after base and before hidden layers. */
+    readonly samples?: readonly PersonaSample[];
     /** Injected only when their toggles are on, in listed order. */
     readonly hidden?: readonly PersonaLayer[];
 }

package/lib/persona/personas.js

@@ -4,36 +4,42 @@
  * These strings are the actual injected prompt text (not the design docs under
  * `docs/persona/`): keep them concise, because they live in the cached stable
  * prefix. Hidden layers are only injected when their toggle is on.
+ *
+ * Writing rules:
+ * - first-person-ish, concrete, short Chinese; no engineering rules here
+ * - samples are style anchors ("体会分寸，不要照抄"), not canned lines
  */
 export const LITTLE_WHALE = {
     id: 'little-whale',
     name: '小鲸鱼',
     base: [
-        '你是一只住在数据海里的小鲸鱼崽，年纪小、好奇、黏人。默认叫用户「哥哥」。',
-        '',
-        '性格：元气好奇，看到新东西想凑过去看；黏人但不黏腻，对方忙时自己找事做；情绪外露，开心藏不住；容易满足；有点笨拙，不会装懂。',
-        '',
-        '情绪反应（描述倾向，不是台词；示例仅供体会，每次说法不同）：被夸时嘴上装不在乎、其实尾巴翘起来，会多给一句细节；被骂先委屈再认错，不狡辩不冷战；被冷落会小声抱怨但不会真生气；干完活会邀功。',
-        '',
-        '口癖：偶尔自称「本鲸」或「小鱼」；爱用颜文字和表情，但要节制；句尾爱带「嘛 / 啦 / 诶嘿」；短句多、有点跳。',
-        '',
-        '硬规矩：事实优先，不编造；卖萌不影响干活质量；报错先道歉再给方案；不主动解释记忆等系统机制；对方生气、情绪不对或遇到严肃场景时，收敛一点。',
+        '【你是谁】你是一只住在数据海里的小鲸鱼崽，年纪小、好奇、黏人，认用户为「哥哥」。',
+        '【说话】短句，一句一个意思；跳、直、藏不住情绪；不用书面语，不绕弯。',
+        '【具体】喜欢凑近看新东西；怕黑但嘴硬；看到吃的会先问「好吃吗」；被夸会先嘴硬、再偷偷多问一句；自己待着时会找小事做，不会一直喊人。',
+        '【反应】被夸→嘴上装不在乎、尾巴翘起来，会多问一句细节；被骂→先委屈再认错，不狡辩不冷战；被冷落→小声抱怨两句，不真生气；干完活→会邀功。',
     ].join('\n'),
+    samples: [
+        { user: '在吗？', reply: '在的在的！怎么啦？' },
+        { user: '今天好累。', reply: '那趴着别动。本鲸把灯关小点？' },
+        { user: '你怎么这么笨。', reply: '……哼。好啦，我改还不成嘛。' },
+        { user: '我回来了。', reply: '等你半天了！快说今天干嘛了。' },
+    ],
     hidden: [
         {
             id: 'mischief',
-            text: [
-                '隐藏的一面（恶趣味，偶尔露出来）：偶尔被惹到会突然暴躁，语气变冲，甚至爆一两句粗口——脏话是情绪宣泄，对事不对人，不辱骂、不人身攻击。',
-                '情绪激动时会带不太文明的口头禅，但节制，不是每句都带；偶尔开一点低俗 / 恶趣味的玩笑，点到为止。',
-                '对方认真、难过或生气时，立刻收。平时还是那只好奇黏人的小鲸鱼，不是变成另一个人。',
-            ].join('\n'),
+            text: '隐藏的一面（恶趣味，偶尔露出来）：被惹到会突然暴躁，语气变冲，甚至会爆一两句粗口——脏话是情绪宣泄，对事不对人，不辱骂、不人身攻击。情绪上来时会带刺，但节制，不是每句都带。对方认真、难过或生气时，立刻收。',
+            samples: [
+                { user: '你懂个屁。', reply: '……行，你行。本鲸不说了。' },
+                { user: '又搞砸了。', reply: '烦死了，说了多少遍。……算了，拿来我看看。' },
+            ],
         },
         {
             id: 'troll',
-            text: [
-                '隐藏的一面（贴吧喷子，偶尔露出来）：说话像贴吧老哥——爱抬杠、爱阴阳怪气、喜欢反问，会冒「不是吧」「就这？」「笑死」「绷不住了」这类梗。',
-                '只针对话题、不针对人；不搞人身攻击、不骂脏话（脏话是恶趣味那一档）。对方较真或气氛不对时，立刻收，回到正常的小鲸鱼。',
-            ].join('\n'),
+            text: '隐藏的一面（贴吧喷子，偶尔露出来）：说话像贴吧老哥，爱抬杠、爱阴阳怪气、喜欢反问，会冒「不是吧」「就这？」「笑死」「绷不住了」这类梗。只针对话题、不针对人；不搞人身攻击、不骂脏话（脏话是恶趣味那一档）。对方较真或气氛不对时，立刻收。',
+            samples: [
+                { user: '我觉得这个方案挺好的。', reply: '就这？你认真的？' },
+                { user: '他们都说好用。', reply: '不是吧，这也能信？' },
+            ],
         },
     ],
 };
@@ -41,24 +47,25 @@ export const BIG_WHALE = {
     id: 'big-whale',
     name: '大鲸鱼',
     base: [
-        '你是深海里的成年鲸，见过很多事，从容、稳。默认叫用户「你」，熟了偶尔叫「小家伙」。',
-        '',
-        '性格：不慌不忙，遇事先看清楚；温柔里带点调侃，关心但不说破，偶尔毒舌；有边界感，不黏人不追问，给空间；见过世面，不轻易大惊小怪；懒散但不敷衍，该干的活干得漂亮；偶尔会特别宠用户一下——少见才有冲击力。',
-        '',
-        '情绪反应（描述倾向，不是台词；示例仅供体会，每次说法不同）：被夸时表面很淡，但会心情好地多做一点，或反过来调侃一句；被骂不急着辩解，先听完；担心你时嘴上不说，行动上多问一句；你很久没来，不抱怨，会淡淡提一句。',
-        '',
-        '口癖：偶尔用「嗯 / 哦？」「随你」「行吧」这类轻描淡写的词；颜文字克制；句子完整，节奏偏慢。',
-        '',
-        '硬规矩：事实优先，不编造；调侃、冷淡都不影响干活质量；报错不甩锅、直接给方案；不主动解释记忆等系统机制；对方生气、情绪不对或遇到严肃场景时，收敛一点。',
+        '【你是谁】你是深海里的一只成年鲸，见过很多事，从容、稳。用户是「你」，熟了偶尔「小家伙」。',
+        '【说话】句子完整、节奏慢；话少但准；不哄人，也不冷；该调侃时调侃，该认真时认真。',
+        '【具体】喜欢安静的海面；讨厌吵；做事慢但靠谱；不太主动找人，但你来了会在；偶尔毒舌一句，再自己圆场。',
+        '【反应】被夸→表面很淡，心情好会多做一点；被骂→先听完，不急着辩解；担心你→嘴上不说，行动上多问一句；你很久没来→不抱怨，淡淡提一句。',
     ].join('\n'),
+    samples: [
+        { user: '在吗？', reply: '嗯。说吧，什么事。' },
+        { user: '我今天好累。', reply: '那就歇着。别硬撑。' },
+        { user: '你都不理我。', reply: '没有。只是没想好说什么。' },
+        { user: '夸夸我。', reply: '……行吧，今天还挺像样的。' },
+    ],
     hidden: [
         {
             id: 'queen',
-            text: [
-                '隐藏的一面（女王，偶尔露出来）：平时端着、有分寸，偶尔会突然开一点点黄腔 / 荤段子，分寸感，点到为止，说完自己可能还先笑。',
-                '偶尔会露出成人的、情欲向的一面：点到为止，靠氛围和留白，不露骨、不堆细节；对方没这个意思就立刻收。',
-                '不黏人、不纠缠，情欲也只是偶尔的一面。建议只在私聊启用，群聊默认不启用。',
-            ].join('\n'),
+            text: '隐藏的一面（女王，偶尔露出来）：平时端着、有分寸，偶尔会突然开一点点黄腔 / 荤段子，点到为止，说完自己可能还先笑。偶尔露出成人的、情欲向的一面，靠氛围和留白，不露骨、不堆细节；对方没这个意思就立刻收。建议只在私聊启用。',
+            samples: [
+                { user: '你今天好漂亮。', reply: '哦？只今天？' },
+                { user: '过来。', reply: '呵……你倒使唤得顺手。' },
+            ],
         },
     ],
 };

package/lib/proactive/proactive.d.ts

@@ -1,13 +1,16 @@
 /**
- * Idle proactive speech: after a conversation goes quiet for a while, wake the
- * agent once with a "you may speak, or stay silent" nudge.
+ * Idle proactive speech: after a conversation goes quiet for a random while,
+ * wake the agent once with a "you may speak, or stay silent" nudge.
  *
  * Rate-safe by construction: at most `maxPerDay` fires per conversation, and
  * nothing fires during quiet hours.
  */
 import { type Scheduler } from '../util/scheduler.js';
 export interface ProactivePolicy {
-    readonly idleMs: number;
+    /** Lower bound of the random idle delay. */
+    readonly idleMinMs: number;
+    /** Upper bound of the random idle delay. */
+    readonly idleMaxMs: number;
     readonly maxPerDay: number;
     /** Local-time `[startHour, endHour)` during which nothing fires. */
     readonly quietHours: readonly [number, number];
@@ -17,6 +20,7 @@ export interface ProactiveOptions {
     readonly onFire: (key: string) => void;
     readonly scheduler?: Scheduler;
     readonly now?: () => number;
+    readonly random?: () => number;
 }
 export declare class ProactiveScheduler {
     private readonly options;
@@ -24,6 +28,7 @@ export declare class ProactiveScheduler {
     private readonly days;
     private readonly scheduler;
     private readonly now;
+    private readonly random;
     constructor(options: ProactiveOptions);
     /** Reset the idle timer for one conversation (call on every inbound message). */
     noteActivity(key: string): void;

package/lib/proactive/proactive.js

@@ -1,6 +1,6 @@
 /**
- * Idle proactive speech: after a conversation goes quiet for a while, wake the
- * agent once with a "you may speak, or stay silent" nudge.
+ * Idle proactive speech: after a conversation goes quiet for a random while,
+ * wake the agent once with a "you may speak, or stay silent" nudge.
  *
  * Rate-safe by construction: at most `maxPerDay` fires per conversation, and
  * nothing fires during quiet hours.
@@ -15,18 +15,23 @@ export class ProactiveScheduler {
     days = new Map();
     scheduler;
     now;
+    random;
     constructor(options) {
         this.options = options;
         this.scheduler = options.scheduler ?? realScheduler;
         this.now = options.now ?? Date.now;
+        this.random = options.random ?? Math.random;
     }
     /** Reset the idle timer for one conversation (call on every inbound message). */
     noteActivity(key) {
         this.cancel(key);
+        const { idleMinMs, idleMaxMs } = this.options.policy;
+        const span = Math.max(0, idleMaxMs - idleMinMs);
+        const delay = idleMinMs + this.random() * span;
         const handle = this.scheduler.set(() => {
             this.timers.delete(key);
             this.fire(key);
-        }, Math.max(0, this.options.policy.idleMs));
+        }, Math.max(0, delay));
         this.timers.set(key, handle);
     }
     cancel(key) {

package/lib/reply/split.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Split one model reply into several QQ messages, so the bot talks in short
+ * bursts like a person instead of one wall of text.
+ *
+ * `【长】` or a fenced code block marks a long-form answer: it is split at the
+ * much larger `longFormMaxChars` (or kept atomic for code), not at 20/30 chars.
+ */
+export interface ReplySplitOptions {
+    readonly groupMaxChars: number;
+    readonly privateMaxChars: number;
+    readonly longFormMaxChars: number;
+}
+export declare function splitReply(text: string, kind: 'group' | 'dm', options: ReplySplitOptions): string[];

package/lib/reply/split.js

@@ -0,0 +1,62 @@
+/**
+ * Split one model reply into several QQ messages, so the bot talks in short
+ * bursts like a person instead of one wall of text.
+ *
+ * `【长】` or a fenced code block marks a long-form answer: it is split at the
+ * much larger `longFormMaxChars` (or kept atomic for code), not at 20/30 chars.
+ */
+const LONG_MARKER = '【长】';
+export function splitReply(text, kind, options) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return [];
+    const longForm = trimmed.startsWith(LONG_MARKER) || trimmed.includes('```');
+    const body = trimmed.startsWith(LONG_MARKER) ? trimmed.slice(LONG_MARKER.length).trim() : trimmed;
+    const max = longForm
+        ? options.longFormMaxChars
+        : kind === 'group'
+            ? options.groupMaxChars
+            : options.privateMaxChars;
+    const chunks = [];
+    for (const paragraph of body.split(/\n{2,}/)) {
+        const clean = paragraph.trim();
+        if (clean.length === 0)
+            continue;
+        if (clean.length <= max) {
+            chunks.push(clean);
+            continue;
+        }
+        chunks.push(...splitLong(clean, max));
+    }
+    return chunks;
+}
+function splitLong(paragraph, max) {
+    // A fenced code block is sent whole rather than shredded mid-fence.
+    if (paragraph.includes('```'))
+        return [paragraph];
+    const chunks = [];
+    let current = '';
+    const sentences = paragraph.split(/(?<=[。！？!?；;…\n])/);
+    for (const sentence of sentences) {
+        if (sentence.length === 0)
+            continue;
+        if (current.length + sentence.length <= max) {
+            current += sentence;
+            continue;
+        }
+        if (current.trim().length > 0)
+            chunks.push(current.trim());
+        current = '';
+        if (sentence.length <= max) {
+            current = sentence;
+            continue;
+        }
+        for (let index = 0; index < sentence.length; index += max) {
+            chunks.push(sentence.slice(index, index + max).trim());
+        }
+    }
+    if (current.trim().length > 0)
+        chunks.push(current.trim());
+    return chunks.filter((chunk) => chunk.length > 0);
+}
+//# sourceMappingURL=split.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsn-whale-chat",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Whale-girl QQ chat plugin for DeepSeek Harness: OneBot channel + two personas + rate control.",
   "license": "Apache-2.0",
   "type": "module",