fix(qq): prevent turn feed message spam

test/channels/qq/bridge.test.mjs

@@ -554,20 +554,26 @@ test('QQ remembers any authorized private inbound as a connection-test target',
   assert.equal(sent.length, 2);
 });
 
-test('QQ pushes the final answer without streaming intermediate text frames', async () => {
+test('QQ private messages produce one final stream bubble', async () => {
   const sent = [];
+  const frames = [];
   const seen = new Set();
   const bridge = new QqHarnessBridge({
     bot: {
       sendText: async (_target, text) => sent.push(text),
+      openStream: () => ({
+        update: async (text) => frames.push(text),
+        complete: async () => frames.push('DONE'),
+        cancel() {},
+      }),
     },
     ownerUserOpenid: 'owner-openid',
     harness: {
       sessionExists: async () => true,
       createSession: async () => 'session-new',
       ensureRunning: async () => true,
-      ask: async (_session, _text, { onUpdate }) => {
-        // 正文流式帧不逐帧推送；最终回答与已暂存文本相同时不重复补发。
+      ask: async (_session, _text, { onUpdate, progressMode }) => {
+        assert.equal(progressMode, 'all');
         await onUpdate({ type: 'text', text: '最终回' });
         await onUpdate({ type: 'text', text: '最终回答' });
         return '最终回答';
@@ -583,16 +589,52 @@ test('QQ pushes the final answer without streaming intermediate text frames', as
   });
 
   await bridge.accept(message());
-  assert.deepEqual(sent, ['最终回答']);
+  assert.deepEqual(frames, ['最终回答', 'DONE']);
+  assert.deepEqual(sent, []);
   assert.equal(seen.has('msg-1'), true);
   assert.equal(bridge.status.messagesReplied, 1);
 });
 
-test('QQ pushes one notice per tool call and ignores status frames', async () => {
+test('QQ does not duplicate a visible private answer when stream completion fails', async () => {
+  const frames = [];
   const sent = [];
   const bridge = new QqHarnessBridge({
     bot: {
       sendText: async (_target, text) => sent.push(text),
+      openStream: () => ({
+        update: async (text) => frames.push(text),
+        complete: async () => { throw new Error('already submitted'); },
+        cancel() {},
+      }),
+    },
+    ownerUserOpenid: 'owner-openid',
+    harness: {
+      sessionExists: async () => true,
+      ask: async () => '最终回答',
+    },
+    state: {
+      hasSeen: () => false,
+      markSeen: async () => {},
+      sessionFor: () => 'session-stream-complete-failure',
+      setSession: async () => {},
+      clearSession: async () => {},
+    },
+    logger: { warn() {}, error() {} },
+  });
+
+  await bridge.accept(message({ messageId: 'msg-stream-complete-failure' }));
+  assert.deepEqual(frames, ['最终回答']);
+  assert.deepEqual(sent, []);
+  assert.equal(bridge.status.messagesReplied, 1);
+});
+
+test('QQ group messages suppress every successful progress update', async () => {
+  const sent = [];
+  let streamCalls = 0;
+  const bridge = new QqHarnessBridge({
+    bot: {
+      sendText: async (_target, text) => sent.push(text),
+      openStream: () => { streamCalls += 1; throw new Error('group stream must not open'); },
     },
     ownerUserOpenid: 'owner-openid',
     harness: {
@@ -615,12 +657,18 @@ test('QQ pushes one notice per tool call and ignores status frames', async () =>
     },
   });
 
-  await bridge.accept(message({ messageId: 'msg-status-frame' }));
-  // 工具调用本身不推送，避免多工具任务刷屏。
+  await bridge.accept(message({
+    kind: 'group',
+    rawEventType: 'GROUP_AT_MESSAGE_CREATE',
+    groupOpenid: 'group-progress',
+    messageId: 'msg-status-frame',
+    replyTarget: { scope: 'group', targetId: 'group-progress', msgId: 'msg-status-frame' },
+  }));
   assert.deepEqual(sent, ['最终回答']);
+  assert.equal(streamCalls, 0);
 });
 
-test('QQ pushes a failed tool error and any interim explanation text', async () => {
+test('QQ group messages append tool failures to one final answer', async () => {
   const sent = [];
   const bridge = new QqHarnessBridge({
     bot: {
@@ -653,12 +701,15 @@ test('QQ pushes a failed tool error and any interim explanation text', async ()
     },
   });
 
-  await bridge.accept(message({ messageId: 'msg-tool-error' }));
+  await bridge.accept(message({
+    kind: 'group',
+    rawEventType: 'GROUP_AT_MESSAGE_CREATE',
+    groupOpenid: 'group-error',
+    messageId: 'msg-tool-error',
+    replyTarget: { scope: 'group', targetId: 'group-error', msgId: 'msg-tool-error' },
+  }));
   assert.deepEqual(sent, [
-    '实体不存在，先创建再添加观察：',
-    'Tool call add_observations\nError: Error calling add_observations. Status code: 404.',
-    '改用创建实体的方式：',
-    '已存入两套记忆。',
+    '已存入两套记忆。\n\n---\n\nTool call add_observations\nError: Error calling add_observations. Status code: 404.',
   ]);
 });
 
@@ -734,7 +785,7 @@ test('QQ falls back to plain text when the platform rejects markdown', async ()
   assert.equal(bridge.status.lastError, null);
 });
 
-test('QQ announces a stopped turn after any tool notices already pushed', async () => {
+test('QQ announces a stopped turn and closes its unused private stream', async () => {
   const fixture = stateFixture([['c2c:owner-openid', 'session-stopped']]);
   const sent = [];
   let loggedErrors = 0;

test/channels/qq/markdown-reply.test.mjs

@@ -65,6 +65,13 @@ test('chunkMarkdownText hard-splits an oversized single line', () => {
   assert.deepEqual(chunks, ['x'.repeat(100), 'x'.repeat(100), 'x'.repeat(50)]);
 });
 
+test('chunkMarkdownText does not split an emoji surrogate pair', () => {
+  const chunks = chunkMarkdownText(`1234😀5678`, 5);
+  assert.equal(chunks.join(''), '1234😀5678');
+  assert.equal(chunks.some((chunk) => chunk.includes('\uFFFD')), false);
+  for (const chunk of chunks) assert.ok(chunk.length <= 5);
+});
+
 test('sendMarkdownReply sends markdown with unique msg_seq per chunk', async () => {
   const calls = [];
   const results = await sendMarkdownReply({
@@ -147,6 +154,44 @@ test('sendMarkdownReply delivers long answers as multiple markdown chunks', asyn
   assert.equal(markdownChunks.join('\n'), text);
 });
 
+test('sendMarkdownReply moves overflow chunks off the passive group reply target', async () => {
+  const targets = [];
+  const groupTarget = { scope: 'group', targetId: 'group-1', msgId: 'group-msg' };
+  await sendMarkdownReply({
+    send: async ({ target: sentTarget }) => {
+      targets.push(sentTarget);
+      return { id: `id-${targets.length}` };
+    },
+    sendText: async () => { throw new Error('unexpected'); },
+  }, groupTarget, 'x'.repeat(4_500 * 6));
+
+  assert.equal(targets.length, 6);
+  assert.equal(targets.slice(0, 4).every((sentTarget) => sentTarget.msgId === 'group-msg'), true);
+  assert.deepEqual(targets.slice(4), [
+    { scope: 'group', targetId: 'group-1' },
+    { scope: 'group', targetId: 'group-1' },
+  ]);
+});
+
+test('sendMarkdownReply uses the reserved passive reply for a visible partial notice', async () => {
+  const groupTarget = { scope: 'group', targetId: 'group-1', msgId: 'group-msg' };
+  const notices = [];
+  const results = await sendMarkdownReply({
+    send: async ({ target: sentTarget }) => {
+      if (!sentTarget.msgId) throw new Error('proactive disabled');
+      return { id: 'passive' };
+    },
+    sendText: async (sentTarget, text) => {
+      if (!sentTarget.msgId) throw new Error('proactive disabled');
+      notices.push(text);
+      return { id: 'partial-notice' };
+    },
+  }, groupTarget, 'x'.repeat(4_500 * 6), { logger: { warn() {} } });
+
+  assert.equal(results.length, 5);
+  assert.deepEqual(notices, ['回答较长，后续内容未能通过 QQ 完整发送，请回复“继续”。']);
+});
+
 test('sendMarkdownReply returns no deliveries for empty text', async () => {
   const results = await sendMarkdownReply({
     send: async () => { throw new Error('unexpected'); },