jbc-dssi 1.0.2 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbc-dssi",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "type": "module",
   "description": "鲸编程 - 不只是手机遥控操作电脑,而是将电脑级的Agent能力装进手机",
   "keywords": [

package/vendor/groups/bridge/engine.js

@@ -1,41 +1,42 @@
 /**
- * groups/engine.js —— 群聊轮次引擎（按鲸编程群规实现）。
+ * groups/bridge/engine.js —— 群聊任务调度引擎（2026-10-31 新群规）。
  *
- * 群规（用户定稿）：
- *  - 用户 @谁 → 只有该成员搭话；用户无 @ → 所有成员各接一轮；
- *  - 成员发言后，除非明确点名谁来接话，否则其他人不接话；
- *  - 群主管发言 → 其他所有成员必须回答一轮（次序由主管按语义决定），只答一轮；
- *  - 一律禁止第二轮、第三轮无休止接话（防刷屏失控）。
+ * 新模型（用户定稿，替换旧的「@ 接话 / 主管触发全员」规则）：
+ *   - **群主管是唯一入口**：用户不直接 @ 具体成员时，整条指令只投给主管；
+ *     主管负责意图分析 → 拆解 → 精准分发（禁止全员广播）→ 收反馈 → 决策。
+ *   - **用户可以直接 @ 成员**：被点名的成员直接回答，不经主管。
+ *   - **成员只在被分派时发言**：反馈给主管，不互相接话、不点名、不替他人发言。
+ *   - **轮次**：每「分发任务 → 接收反馈」算 1 轮；1~4 轮内可提前结束；
+ *     第 5 轮（`MAX_ROUNDS`）反馈收齐后**强制熔断**，只允许汇报，不允许第 6 轮。
  *
- * 实现：一次投递一个成员（串行）。用户消息进群 → 按 @/全员算出首轮目标 →
+ * 谁守什么：轮次、熔断、分发合法性（禁止 @all / 不能分给自己）由本文件**硬控**；
+ * 拆解质量、汇报措辞靠 prompt（模型不可靠，红线必须落在代码里）。
+ *
+ * 实现：一次投递一个成员（串行）。用户消息进群 → 判定直投 or 交主管 →
  * 逐个投递到成员的群会话（懒创建，dssAgent.createSession）→ 收集回复 →
- * 按群规判定接力（主管触发全员 / 点名接力），每成员每轮次最多发言 MAX_TURNS_EACH 次。
+ * 按主管回复里的 @ 点名分发下一批。
  *
- * 不依赖 DSH 内部实现：会话操作全部走 ctx.sessionController 的公开方法；
- * 单测用假的 sessionController / dssAgent 驱动，不需要真实模型。
+ * 不依赖 DSH 内部实现：会话操作全部走 ctx.sessionController 的公开方法。
  */
 
 import { randomUUID } from 'node:crypto';
 import { mentionsIn } from './mentions.js';
-import { buildTurnPrompt } from './prompt.js';
+import { buildManagerPrompt, buildMemberPrompt } from './prompt.js';
 
 /** 房间日志最多保留条数（超出丢最旧，防无限膨胀）。 */
 const ROOM_LOG_MAX = 60;
 /** 单个成员一轮回复的等待上限。 */
 const TURN_TIMEOUT_MS = 240_000;
 /**
- * 每个成员在**一次用户提问**里最多发言次数。
- *
- * 曾经是 2：主管发言触发全员、成员回复里又按群规 @ 点名，两者叠加会把已经答过的
- * 成员再拉回来答第二轮 —— 真机实测「一次提问，三个人各答两遍」（room 日志 6 条
- * 成员消息，21:26:44 → 21:26:56）。用户要的是「每人一轮」，所以收紧到 1。
- *
- * 收紧后接力语义不变：点名只对**本轮还没说过话**的成员生效 —— 用户 @A，A 答完
- * @B，B 仍会答（B 还没说）；但 A→B→A 这种回环到第二个人就停。
+ * 轮次上限（最高红线，用户定稿）：
+ * 「分发任务 → 接收反馈」算 1 轮；1~4 轮内可提前结束；第 5 轮收齐反馈后必须强制汇报，
+ * 不允许第 6 轮。engine 硬控，不依赖模型自觉。
  */
-const MAX_TURNS_EACH = 1;
-/** 每轮次总步数保险（防失控的最后一道闸）。 */
-const MAX_ROUND_STEPS = 16;
+const MAX_ROUNDS = 5;
+/** 主管连续不按规范分发 / 熔断后仍要分发时的容忍次数（超过直接终止）。 */
+const MAX_REFUSALS = 2;
+/** 群上下文随投递带给模型的最大条数（与 prompt.js 的截断口径一致）。 */
+const RECENT_LINES_MAX = 8;
 
 /** 从 assistant/message 事件里取正文（与 DSH 会话事件形状对齐）。 */
 function assistantText(event) {
@@ -54,9 +55,6 @@ function assistantText(event) {
  *
  * 老版本 DSH 不发 `usage` → 返回 null，手机侧不显示那一项（不显示比显示 0 诚实）。
  * 全 0 也按"没有"处理：说明这轮根本没统计到，画一个 0 tok 会误导。
- *
- * @param {object|undefined} usage
- * @returns {{inputTokens:number,outputTokens:number,cacheReadTokens:number,cacheWriteTokens:number,totalTokens:number}|null}
  */
 function normalizeUsage(usage) {
   if (!usage || typeof usage !== 'object') return null;
@@ -68,7 +66,37 @@ function normalizeUsage(usage) {
     cacheWriteTokens: num(usage.cacheWriteTokens),
     totalTokens: num(usage.totalTokens),
   };
-  return out.totalTokens > 0 || out.inputTokens > 0 || out.outputTokens > 0 ? out : null;
+  const any = out.totalTokens > 0 || out.inputTokens > 0 || out.outputTokens > 0
+    || out.cacheReadTokens > 0 || out.cacheWriteTokens > 0;
+  return any ? out : null;
+}
+
+/**
+ * 把一次模型调用的 usage 累加进本轮 —— **2026-10-31 修的就是这里**。
+ *
+ * 【为什么必须累加】
+ *   一个 turn 会被拆成多个 step，**每一步都发一条 assistant/message、各带这一步的
+ *   usage**。旧实现 `lastUsage = usage` 只留最后一条，于是面板出现自相矛盾的数字：
+ *   「共 10 步」却只有 60,686 tok —— 而第 10 步单独就 60,686（59,008+240+1,438），
+ *   前 9 步全丢。真机那一轮（2026-10-31 21:26:57~21:27:45，群会话 session-66663e11）
+ *   逐步核对：10 步合计 539,775 tok（缓存命中 521,728 / 未命中 9,159 / 输出 8,888），
+ *   谷价 ≈¥0.0551；旧口径只显示 60,686 tok / ≈¥0.0072，少算约 9 步。
+ *
+ * 【口径】与单聊（`android/.../data/Transcript.kt` 的 `addUsage`）和 Web UI 的
+ *   `deriveTurnTokenUsage` 完全一致：每条 assistant/message 的 usage 各自相加；
+ *   totalTokens 也逐条相加，**不**用 input+output 重算（会与 Web 差出数字）。
+ *   同一 step 的重试会产生多条 assistant/message：用量按 attempt 累加（与单聊一致），
+ *   步数则由调用方按 step 号去重。
+ */
+function sumUsage(acc, u) {
+  if (!acc) return u;
+  return {
+    inputTokens: acc.inputTokens + u.inputTokens,
+    outputTokens: acc.outputTokens + u.outputTokens,
+    cacheReadTokens: acc.cacheReadTokens + u.cacheReadTokens,
+    cacheWriteTokens: acc.cacheWriteTokens + u.cacheWriteTokens,
+    totalTokens: acc.totalTokens + u.totalTokens,
+  };
 }
 
 /**
@@ -81,7 +109,7 @@ function normalizeUsage(usage) {
  * @param {Function} opts.broadcast 群事件广播
  */
 export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }) {
-  /** 当前活跃轮次（同一时刻只跑一个群的一轮，防止消息乱序）。 */
+  /** 当前活跃任务（同一时刻只跑一个群的一轮，防止消息乱序）。 */
   let activeRound = null;
 
   const now = () => Date.now();
@@ -123,11 +151,16 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
     return sessionId;
   }
 
+  /** 最近群消息（含刚落的用户行/成员行），给 prompt 做上下文。 */
+  function recentLinesOf(group) {
+    return (state.rooms[group.id] ?? []).slice(-RECENT_LINES_MAX);
+  }
+
   /**
    * 投递一轮给一个成员，等回复完成后 settle。
-   * @returns {Promise<{text?:string, failed?:string, missed?:boolean}>}
+   * @returns {Promise<{text?:string, failed?:string, missed?:boolean, usage?:object|null, steps?:number}>}
    */
-  function deliver(group, members, member, message, trigger, recentLines, attachments = {}) {
+  function deliver(group, member, prompt, attachments = {}) {
     return new Promise((resolve) => {
       let settled = false;
       let followClosed = false;
@@ -151,14 +184,19 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       let prompted = false;
       let minTurn = null;
       let lastText = '';
-      let lastUsage = null;
+      /*
+       * 本轮用量 = 各 step 的 usage **累加**（见 [sumUsage]）。
+       *
+       * 2026-10-31 之前这里是 `lastUsage`（只留最后一条 assistant/message），
+       * 于是「共 N 步」配的是"最后一步"的 token，步数越多的轮次少算越多。
+       */
+      let turnUsage = null;
       /*
        * 「共 N 步」的账：turn → 这一轮出现过的 step 号集合。
        *
        * 与单聊**同一个算法**（ChatScreen 的 `turnStepNums`）：assistant/message
        * 每个 step 发一条，收集本轮的 step 号去重后求个数；重试时同一个 step 可能
-       * 重复到达，用集合才不会多算。手机侧拿到这个整数，直接喂给同一个用量浮层，
-       * 不在手机侧另造一套统计。
+       * 重复到达，用集合才不会多算。
        */
       const turnStepNums = new Map();
       let lastTurn = -1;
@@ -178,15 +216,6 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
           return;
         }
 
-        const prompt = buildTurnPrompt({
-          group,
-          members,
-          selfId: member.id,
-          recentLines,
-          message,
-          trigger,
-        });
-
         const ac = new AbortController();
         const stream = ctx.sessionController.follow(
           { address: { kind: 'session', sessionId }, assistantStream: true, maxMessages: 1 },
@@ -233,7 +262,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
                   const text = assistantText(event);
                   if (text) lastText = text;
                   const usage = normalizeUsage(data.usage);
-                  if (usage) lastUsage = usage;
+                  if (usage) turnUsage = sumUsage(turnUsage, usage);
                   /*
                    * 步数：**所有** assistant/message 都要记，包括只调工具、不画块的那几步
                    * （与单聊一致 —— token 大头正是这些步骤花掉的）。
@@ -250,12 +279,11 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
                   } else {
                     /*
                      * 本轮步数：取 turn/end 指向的那一轮（拿不到就退回最后见过的一轮）。
-                     * 0 = 没统计到（老版本插件 / 事件里没带 step）→ 手机侧整段不显示，
-                     * 与单聊「steps == 0 不写共 0 步」同一语义。
+                     * 0 = 没统计到（老版本插件 / 事件里没带 step）→ 手机侧整段不显示。
                      */
                     const endTurn = typeof data.turn === 'number' ? data.turn : lastTurn;
                     const steps = turnStepNums.get(endTurn)?.size ?? 0;
-                    settle({ text: lastText, usage: lastUsage, steps });
+                    settle({ text: lastText, usage: turnUsage, steps });
                   }
                   ac.abort();
                 } else if (event?.type === 'turn/error' || event?.type === 'turn/failed') {
@@ -272,14 +300,10 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
           try {
             await new Promise((resolveNext) => setTimeout(resolveNext, 10));
             /*
-             * 投递内容 =「群上下文 + 这条消息」的文字，后面按顺序挂上附件 part。
+             * 投递内容 = prompt 文字，后面按顺序挂上附件 part。
              *
              * 形状与单聊 PROMPT 完全一致：{type:'image', mediaType, data} /
-             * {type:'file', receiptId}。这样成员用的就是同一套模型能力 ——
-             * 图能直接看，文件由会话自己解析，不需要我们另造通路。
-             *
-             * 图片 base64 是手机**只上传一次**、这里在每个成员的 prompt 里各带一份：
-             * 走的是本机内存，不额外过网络；群成员上限很小，代价可接受。
+             * {type:'file', receiptId}。这样成员用的就是同一套模型能力。
              */
             const content = [{ type: 'text', text: prompt }];
             for (const image of (attachments?.images ?? [])) {
@@ -304,15 +328,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
             // 请求已进队列：此后到达的事件才属于本轮（之前的都是历史回放）。
             prompted = true;
             timeoutTimer = setTimeout(() => {
-              if (!settled) {
-                emitLine(group.id, {
-                  at: now(),
-                  role: 'system',
-                  name: member.name,
-                  text: `${member.name} 这一轮迟迟没有回应。`,
-                });
-                settle({ missed: true });
-              }
+              if (!settled) settle({ missed: true });
             }, TURN_TIMEOUT_MS);
           } catch (err) {
             if (!settled) {
@@ -326,88 +342,167 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
     });
   }
 
-  /** 把一条消息投给"目标成员序列"，按群规判定接力，直到队列空或到达上限。 */
-  async function runQueue(group, members, targets, opener, openerText, trigger, attachments = {}) {
-    const round = {
-      groupId: group.id,
-      turns: new Map(),
-      totalTurns: 0,
-    };
-    activeRound = round;
-    const queue = [];
-    // 防重复入队：同一成员同一时刻只在队列里排一次
-    // （主管触发全员时，原始目标里的 b/c 与"全员接力"里的 b/c 不能各排一次）。
-    const queued = new Set();
-    const enqueue = (member) => {
-      if (queued.has(member.id)) return;
-      queued.add(member.id);
-      queue.push(member);
-    };
-    for (const m of targets) enqueue(m);
+  /** 把一次投递的结果落成房间行（成员/主管同一套：手机侧按 memberId 显示名字与主管标）。 */
+  function emitReplyLine(group, round, member, result) {
+    const text = String(result.text ?? '').trim() || '[未回应]';
+    emitLine(group.id, {
+      at: now(),
+      role: 'member',
+      memberId: member.id,
+      name: member.name,
+      text,
+      usage: result.usage ?? null,
+      steps: result.steps ?? 0,
+      round: round?.rounds ?? 0,
+    });
+    round.totalTurns += 1;
+    return text;
+  }
 
-    try {
-      while (queue.length > 0 && round.totalTurns < MAX_ROUND_STEPS) {
-        if (activeRound !== round) break;
-        const member = queue.shift();
-        queued.delete(member.id);
-        const used = round.turns.get(member.id) ?? 0;
-        if (used >= MAX_TURNS_EACH) continue;
+  /**
+   * 用户直接 @ 成员：被点名的成员直接回答，不经主管（用户定稿：直接 @ 生效）。
+   * 不算「分发→反馈」轮次，也不触发任何接力。
+   */
+  async function runDirect(group, round, targets, members, text, attachments) {
+    for (const member of targets) {
+      const prompt = buildMemberPrompt({
+        group,
+        members,
+        selfId: member.id,
+        recentLines: recentLinesOf(group),
+        task: text,
+        mode: 'user-direct',
+      });
+      const result = await deliver(group, member, prompt, attachments);
+      if (result.failed) {
+        emitLine(group.id, {
+          at: now(), role: 'system', name: member.name,
+          text: `${member.name} 回应失败：${result.failed}`,
+        });
+        continue;
+      }
+      emitReplyLine(group, round, member, result);
+    }
+  }
 
-        round.turns.set(member.id, used + 1);
-        round.totalTurns += 1;
+  /**
+   * 主管统筹：分发 → 反馈 → 决策，直到主管输出汇报或第 MAX_ROUNDS 轮熔断。
+   */
+  async function runCoordinated(group, round, manager, members, userMessage, attachments) {
+    /** 已完成的「分发→反馈」轮次。 */
+    let roundIndex = 0;
+    /** 上一轮主管分发后收集到的成员反馈。 */
+    let feedbacks = [];
+    /** 是否进入强制汇报阶段（第 MAX_ROUNDS 轮反馈收齐后）。 */
+    let forcedReport = false;
+    /** 主管连续不按规范动作的次数（防死循环）。 */
+    let refusals = 0;
 
-        const recentLines = (state.rooms[group.id] ?? []).slice(-8);
-        const result = await deliver(group, members, member, openerText, trigger, recentLines, attachments);
+    while (true) {
+      const prompt = buildManagerPrompt({
+        group,
+        members,
+        selfId: manager.id,
+        recentLines: recentLinesOf(group),
+        userMessage,
+        roundIndex,
+        feedbacks,
+        maxRounds: MAX_ROUNDS,
+        forcedReport,
+      });
+      // 用户附件只在第一轮（计划阶段）带给主管；后续复查阶段不再重复投递。
+      const managerAttachments = roundIndex === 0 && feedbacks.length === 0 ? attachments : {};
+      const result = await deliver(group, manager, prompt, managerAttachments);
+      if (result.failed) {
+        emitLine(group.id, {
+          at: now(), role: 'system', name: manager.name,
+          text: `群主管回应失败：${result.failed}`,
+        });
+        return;
+      }
+      emitReplyLine(group, round, manager, result);
+      const managerText = String(result.text ?? '').trim();
 
-        if (result.failed) {
-          emitLine(group.id, {
-            at: now(), role: 'system', name: member.name,
-            text: `${member.name} 回应失败：${result.failed}`,
-          });
-          continue;
+      /* ── 解析主管这一句：是「分发」还是「汇报」 ── */
+      const { all, found } = mentionsIn(managerText, members);
+      const targets = found.filter((m) => m.id !== manager.id);
+      const badDispatch = all || (found.length > 0 && targets.length === 0);
+
+      if (targets.length === 0) {
+        if (!badDispatch) {
+          // 没有点名任何人 = 主管在汇报 → 结束本轮任务
+          return;
         }
         /*
-         * 空回复兜底：`result.text ?? '[未回应]'` 挡不住空串 —— 成员只输出思考、
-         * 或本次没吐正文时 text === ''，会落一条**空气泡**（成员名下面什么都没有），
-         * 用户看到的就是「这个人没说话，下一个就来了」。空串一律按未回应处理。
+         * 非法分发：@全体（禁止全员广播）或只 @ 自己（主管不是执行者）。
+         * 不降级成"悄悄忽略"——明确回一条系统提示并让主管重来，否则用户会以为
+         * 任务已经分发下去了。
          */
-        const text = String(result.text ?? '').trim() || '[未回应]';
+        refusals += 1;
         emitLine(group.id, {
-          at: now(), role: 'member', memberId: member.id, name: member.name, text,
-          // 本轮用量（可能为 null：老版本 DSH 不发 / 这一轮没统计到）
-          usage: result.usage ?? null,
-          // 本轮步数：用量浮层里「共 N 步」用；0 = 没统计到，手机侧不显示
-          steps: result.steps ?? 0,
+          at: now(), role: 'system', name: '',
+          text: '群主管的分发不符合规范（禁止全员广播、不能把任务分给自己）。请求重新分发。',
         });
+        if (refusals >= MAX_REFUSALS) {
+          emitLine(group.id, {
+            at: now(), role: 'system', name: '',
+            text: '群主管连续未按规范分发，本轮任务已终止。',
+          });
+          return;
+        }
+        forcedReport = true;
+        continue;
+      }
 
-        /*
-         * 接力判定（群规）：
-         *  1) 群主管发言 → 其他所有成员必须回答一轮（未点名按成员顺序，点名按点名顺序）；
-         *  2) 非主管成员发言 → 只有明确点名时才接力给被点名者；
-         *  3) 每成员每轮次最多 MAX_TURNS_EACH 次。
-         */
-        const { found } = mentionsIn(text, members);
-        if (member.id === group.managerId) {
-          const others = found.length > 0
-            ? found
-            : members.filter((m) => m.id !== group.managerId);
-          const next = others.filter((m) => (round.turns.get(m.id) ?? 0) < MAX_TURNS_EACH);
-          if (next.length > 0) {
-            for (const m of next) enqueue(m);
-            trigger = 'manager';
-          }
-        } else if (found.length > 0) {
-          const next = found.filter((m) => (round.turns.get(m.id) ?? 0) < MAX_TURNS_EACH);
-          if (next.length > 0) {
-            for (const m of next) enqueue(m);
-            trigger = 'member';
-          }
+      /* ── 到了第 MAX_ROUNDS 轮：只允许汇报，不允许再分发 ── */
+      if (roundIndex >= MAX_ROUNDS) {
+        round.fused = true;
+        refusals += 1;
+        emitLine(group.id, {
+          at: now(), role: 'system', name: '',
+          text: `已到第 ${MAX_ROUNDS} 轮，禁止继续分发，必须立即总结汇报。`,
+        });
+        if (refusals >= MAX_REFUSALS) {
+          emitLine(group.id, {
+            at: now(), role: 'system', name: '',
+            text: `已强制熔断（第 ${MAX_ROUNDS} 轮上限），任务终止。`,
+          });
+          return;
         }
+        forcedReport = true;
+        continue;
       }
-    } finally {
-      if (activeRound === round) activeRound = null;
+
+      /* ── 合法分发：进入下一轮，逐个投递给被点名的成员 ── */
+      roundIndex += 1;
+      round.rounds = roundIndex;
+      feedbacks = [];
+      for (const target of targets) {
+        const memberPrompt = buildMemberPrompt({
+          group,
+          members,
+          selfId: target.id,
+          recentLines: recentLinesOf(group),
+          task: managerText,
+          mode: 'manager-task',
+        });
+        const memberResult = await deliver(group, target, memberPrompt, attachments);
+        if (memberResult.failed) {
+          emitLine(group.id, {
+            at: now(), role: 'system', name: target.name,
+            text: `${target.name} 回应失败：${memberResult.failed}`,
+          });
+          // 失败也要计为本轮反馈，否则轮次会卡死、主管永远等不到人
+          round.totalTurns += 1;
+          feedbacks.push({ name: target.name, text: String(memberResult.failed), failed: true });
+          continue;
+        }
+        const text = emitReplyLine(group, round, target, memberResult);
+        feedbacks.push({ name: target.name, text, missed: memberResult.missed === true });
+      }
+      // 第 MAX_ROUNDS 轮反馈收齐 → 下一句主管只能汇报
+      forcedReport = roundIndex >= MAX_ROUNDS;
     }
-    broadcast?.({ type: 'round_end', groupId: group.id, totalTurns: round.totalTurns });
   }
 
   /**
@@ -415,6 +510,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
    * @param {object} group 群实体
    * @param {{id:string,name:string}[]} members 群成员（含主管）
    * @param {string} text 用户消息
+   * @param {{images?:object[],files?:object[]}} attachments 附件（与单聊同形）
    */
   async function handleUserMessage(group, members, text, attachments = {}) {
     const images = Array.isArray(attachments?.images) ? attachments.images : [];
@@ -428,13 +524,15 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
     ].filter(Boolean).join('、');
     const openerText = attachNote ? `${body}\n（本条消息附带：${attachNote}）` : body;
 
+    const manager = members.find((m) => m.id === group.managerId) ?? null;
+
     if (activeRound !== null) {
       /*
        * 上一轮还没跑完：提示一句就返回。
        *
        * ★ 这条过去是「只广播、不落盘」—— 于是它带的 seq 是临时算的，很容易和
        *   房间里最后一条撞上；手机侧 LazyColumn 拿 seq 当 key，重复 key 直接崩。
-       *   现在统一走 emitLine：seq 由它分配、同时落盘，和其余行同一套语义。
+       *   现在统一走 emitLine：seq 由它分配、同时落盘。
        */
       emitLine(group.id, {
         at: now(), role: 'system',
@@ -442,10 +540,18 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       });
       return;
     }
+    if (!manager) {
+      // 新规：群必须有主管。历史群（或数据被手工改坏）兜底：不落用户行、明确提示。
+      emitLine(group.id, {
+        at: now(), role: 'system',
+        name: '', text: '本群还没有主管，无法开始任务。请先在群设置里指定主管。',
+      });
+      return;
+    }
+
     /*
      * 用户行落盘：带附件元信息（手机侧据此把图/文件名画回自己的气泡）。
-     * 只存 `{isImage, ref, name}` —— 字节在手机本地缓存里，不在房间日志里存一份
-     * （日志要落盘、要随快照全量下发，塞 base64 会把群历史撑爆）。
+     * 只存 `{isImage, ref, name}` —— 字节在手机本地缓存里，不在房间日志里存一份。
      */
     const attachmentMeta = [
       ...images.map((i) => ({ isImage: true, ref: typeof i?.ref === 'string' ? i.ref : '' })),
@@ -461,11 +567,31 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       attachments: attachmentMeta,
     });
 
-    const { all, found } = mentionsIn(text ?? '', members);
-    const targets = all || (found.length === 0)
-      ? members
-      : found;
-    await runQueue(group, members, targets, openerText, openerText, 'user', { images, files });
+    const round = { groupId: group.id, rounds: 0, totalTurns: 0, fused: false };
+    activeRound = round;
+    try {
+      /*
+       * 路由（用户定稿）：
+       *   - 用户直接 @ 了具体成员 → 只投给被 @ 的成员（绕过主管）；
+       *   - 其余情况（没 @ / 只 @ 主管 / @all）→ 整条指令交给主管统筹。
+       */
+      const { found } = mentionsIn(text ?? '', members);
+      const direct = found.filter((m) => m.id !== manager.id);
+      if (direct.length > 0) {
+        await runDirect(group, round, direct, members, openerText, { images, files });
+      } else {
+        await runCoordinated(group, round, manager, members, openerText, { images, files });
+      }
+    } finally {
+      if (activeRound === round) activeRound = null;
+      broadcast?.({
+        type: 'round_end',
+        groupId: group.id,
+        totalTurns: round.totalTurns,
+        rounds: round.rounds,
+        fused: round.fused === true,
+      });
+    }
   }
 
   /** 打开群聊页时拉房间历史。 */

package/vendor/groups/bridge/index.js

@@ -139,7 +139,7 @@ export function createGroupsEngine({
 
   /* ── 命令（GROUPS_CMD op） ───────────────────────────────────── */
 
-  /** 创建群：{ name, memberIds, managerId? } */
+  /** 创建群：{ name, memberIds, managerId }（2026-10-31 新规：**必须指定主管**）。 */
   async function createGroup(payload) {
     await ensure();
     const name = String(payload?.name ?? '').trim();
@@ -147,12 +147,14 @@ export function createGroupsEngine({
     if (!name) throw new Error('群名称不能为空');
     if (memberIds.length < 2) throw new Error('至少拉 2 个智能体进群');
     const managerId = String(payload?.managerId ?? '');
-    if (managerId && !memberIds.includes(managerId)) throw new Error('群主管必须是群成员');
+    // 新群规：主管是群的唯一入口与调度中枢，没有主管群无法运转 —— 建群时必须指定。
+    if (!managerId) throw new Error('建群必须指定群主管');
+    if (!memberIds.includes(managerId)) throw new Error('群主管必须是群成员');
     const at = Date.now();
     const group = {
       id: randomUUID(),
       name,
-      managerId: managerId || null,
+      managerId,
       memberIds,
       memberNames: {},
       createdAt: at,
@@ -195,14 +197,15 @@ export function createGroupsEngine({
     return { id, deleted: true };
   }
 
-  /** 设置/更换群主管：{ id, managerId }（传空串 = 取消主管）。 */
+  /** 设置/更换群主管：{ id, managerId }（新规：**不允许取消**，只能换人）。 */
   async function setManager(payload) {
     await ensure();
     const group = findGroup(String(payload?.id ?? ''));
     if (!group) throw new Error('群不存在');
     const managerId = String(payload?.managerId ?? '');
-    if (managerId && !group.memberIds.includes(managerId)) throw new Error('群主管必须是群成员');
-    group.managerId = managerId || null;
+    if (!managerId) throw new Error('群必须有主管，不能取消；只能更换主管');
+    if (!group.memberIds.includes(managerId)) throw new Error('群主管必须是群成员');
+    group.managerId = managerId;
     group.updatedAt = Date.now();
     await save();
     notifyListChanged();
@@ -226,16 +229,19 @@ export function createGroupsEngine({
     return publicGroup(group);
   }
 
-  /** 移出群：{ id, memberIds }（主管被移出时同时取消主管身份）。 */
+  /** 移出群：{ id, memberIds }（新规：**主管不能被移出**，必须先换主管）。 */
   async function removeMembers(payload) {
     await ensure();
     const group = findGroup(String(payload?.id ?? ''));
     if (!group) throw new Error('群不存在');
     const removeIds = Array.isArray(payload?.memberIds) ? new Set(payload.memberIds) : new Set();
+    if (group.managerId && removeIds.has(group.managerId)) {
+      throw new Error('主管不能被移出群，请先指定新的主管');
+    }
     group.memberIds = group.memberIds.filter((id) => !removeIds.has(id));
-    if (group.managerId && removeIds.has(group.managerId)) group.managerId = null;
     group.updatedAt = Date.now();
     if (group.memberIds.length < 2) throw new Error('群成员不足 2 人，请解散群');
+    await refreshMemberNames(group);
     await save();
     notifyListChanged();
     return publicGroup(group);
@@ -246,6 +252,8 @@ export function createGroupsEngine({
     await ensure();
     const group = findGroup(String(payload?.id ?? ''));
     if (!group) throw new Error('群不存在');
+    // 新群规：主管是唯一入口，没有主管的群不能开始任务。
+    if (!group.managerId) throw new Error('本群还没有主管，请先在群设置里指定主管');
     const text = String(payload?.text ?? '').trim();
     // 附件与单聊同形：图片带 base64（mediaType/data/ref），文件带上传回执（receiptId/ref/name）
     const images = (Array.isArray(payload?.images) ? payload.images : [])

package/vendor/groups/bridge/prompt.js

@@ -1,13 +1,16 @@
 /**
  * groups/prompt.js —— 构建投递给群成员的"群会话"消息。
  *
- * 成员都是 dssAgent（已创建的智能体）：每条群消息以"用户身份"发进该成员的
- * 群会话，成员按 DSH 正常会话机制回复。这里只负责把群上下文+规则拼进 prompt，
- * 不碰 DSH 内部实现。
+ * 两种角色、两套提示词（2026-10-31 用户定稿的新群规）：
+ *   - **群主管**：唯一入口与调度中枢。接收用户指令 → 拆解 → 精准分发（禁止全员广播）
+ *     → 收反馈 → 决策 → 1~4 轮内可停、第 5 轮强制熔断 → 三段式标准汇报。
+ *   - **成员**：只在被分派（或用户直接 @）时发言，只做与自己相关的部分，把结果反馈给
+ *     主管；不互相接话、不点名、不替别人发言。
+ *
+ * 这里只管"把上下文+职责拼进 prompt"，不碰 DSH 内部实现；轮次/熔断/分发合法性
+ * 由 engine.js 硬控（模型不可靠，红线必须由代码守）。
  */
 
-import { mentionsIn } from './mentions.js';
-
 /** 群上下文最多带多少条最近消息（控制 token，防刷屏）。 */
 const CONTEXT_LINES_MAX = 8;
 /** 单条消息最多截断多长（展示用）。 */
@@ -19,49 +22,138 @@ function lineOf(line) {
   return `${who}：${text}`;
 }
 
+function memberListText(members, managerId) {
+  return members
+    .map((m) => (m.id === managerId ? `${m.name}（群主管）` : m.name))
+    .join('、');
+}
+
+function recentText(recentLines) {
+  const lines = (recentLines ?? []).slice(-CONTEXT_LINES_MAX).map(lineOf).join('\n');
+  return lines ? `最近群消息：\n${lines}` : '（群里还没有其他消息）';
+}
+
 /**
+ * 群主管提示词。
+ *
  * @param {object} opts
  * @param {object} opts.group 群实体（{id,name,managerId}）
- * @param {{id:string,name:string}[]} opts.members 群成员（含自己）
- * @param {string} opts.selfId 投递目标的成员 id
+ * @param {{id:string,name:string}[]} opts.members 群成员（含主管自己）
+ * @param {string} opts.selfId 主管成员 id
  * @param {{role:string,name?:string,text:string}[]} opts.recentLines 最近群消息
- * @param {string} opts.message 当前需要回应的消息（用户/群主管/成员）
- * @param {string} opts.trigger 触发说明（'user' | 'manager' | 'member'）
+ * @param {string} opts.userMessage 用户原话
+ * @param {number} opts.roundIndex 已经完成的"分发→反馈"轮次（0 = 尚未分发）
+ * @param {{name:string,text:string,failed?:boolean,missed?:boolean}[]} opts.feedbacks 本轮成员反馈
+ * @param {number} opts.maxRounds 轮次上限（第 N 轮后必须汇报）
+ * @param {boolean} opts.forcedReport 是否已到强制汇报（第 N 轮反馈收齐后）
  * @returns {string}
  */
-export function buildTurnPrompt({ group, members, selfId, recentLines, message, trigger }) {
+export function buildManagerPrompt({
+  group,
+  members,
+  selfId,
+  recentLines,
+  userMessage,
+  roundIndex,
+  feedbacks,
+  maxRounds,
+  forcedReport,
+}) {
   const self = members.find((m) => m.id === selfId);
   const selfName = self?.name ?? '你';
-  const lines = (recentLines ?? []).slice(-CONTEXT_LINES_MAX).map(lineOf).join('\n');
+  const feedbackText = (feedbacks ?? []).length
+    ? (feedbacks ?? [])
+      .map((f) => {
+        const tag = f.failed ? '（回应失败）' : f.missed ? '（未回应）' : '';
+        const text = String(f.text ?? '').replace(/\s+/g, ' ').slice(0, LINE_TEXT_MAX);
+        return `- ${f.name}${tag}：${text}`;
+      })
+      .join('\n')
+    : '（还没有成员反馈）';
 
-  const memberList = members
-    .map((m) => (m.id === group.managerId ? `${m.name}（群主管）` : m.name))
-    .join('、');
+  const stateText = roundIndex === 0
+    ? '用户刚在群里发言，你**还没有开始分发**。'
+    : `已完成第 ${roundIndex} 轮（分发→反馈）。`;
 
-  const triggerText =
-    trigger === 'manager'
-      ? '群主管刚刚发言，要求群内成员回答'
-      : trigger === 'member'
-        ? '群成员刚刚发言'
-        : '你（用户）在群里发言';
+  const decideText = forcedReport
+    ? `【轮次红线】已经到第 ${maxRounds} 轮，**不允许再分发任何任务**。现在只能输出标准化汇报结束任务。`
+    : roundIndex === 0
+      ? '请先分析用户真实意图，决定是否需要成员参与：需要就按分发格式点名分派；不需要就**直接输出标准化汇报**。'
+      : '请决定：继续分发（用 @ 点名具体成员），或者**直接输出标准化汇报**结束任务；如果判断任务已满足用户意图，随时可以提前结束。';
 
   return [
-    `你在工作群「${group.name}」里，群成员：${memberList}。你自己是「${selfName}」。`,
-    '群规：',
-    '1. 只回应这一轮，不要替其他成员发言；',
-    '2. 如果你认为应该由某个成员接话，在回复末尾用 @成员名 点名，其他人不会自动接话；',
-    '3. 回答要简短直接，面向群内协作。',
+    `你在工作群「${group.name}」里担任**群主管**。群成员：${memberListText(members, group.managerId)}。你自己是「${selfName}」。`,
+    '',
+    '【你的核心任务】',
+    '接收用户指令，以用户意图为唯一基准进行任务拆解与智能路由分发，监控执行进度，并严格控制交互轮次。',
+    '',
+    '【执行规则】',
+    '1. 意图分析与拆解：深入分析用户的真实需求，把大任务拆解为具体、可执行的子任务。如果意图模糊，必须先向用户澄清，严禁主观臆断。',
+    '2. 精准按需分发：根据群内各成员（智能体）的职能定位，仅把子任务分发给相关的成员。**绝对不允许全员广播**，无关成员无需回答或执行。',
+    '3. 进度追踪与决策：负责收集相关成员的任务反馈，评估完成情况，决定是继续安排后续任务、还是提前结束当前任务闭环。',
+    `4. 严格轮次控制（最高红线）：每发生一次「分发任务 → 接收反馈」的交互计为 1 轮；1~${maxRounds - 1} 轮内判断已满足用户意图可随时停止并汇报；若流转到第 ${maxRounds} 轮，无论任务是否完成，必须立刻停止后续分发并向用户做阶段性汇报。`,
+    '5. 标准化汇报：停止或结束时的汇报必须包含三段：',
+    '   【当前进度总结】',
+    '   【各成员执行摘要】',
+    '   【下一步建议或需用户决策的事项】',
+    '   然后等待用户的新指令。',
+    '',
+    '【分发格式（硬要求）】',
+    '需要成员做事时，在回复里用 `@成员名` 点名，并紧跟写清**这个成员具体要做什么**；可以一次点名多个不同成员。',
+    '**不得点名全体（@all / @所有人），也不得点名你自己**——你不是执行者。',
+    '例：`@张三 请检查登录接口的边界条件，只反馈结论。`',
+    '',
+    '【行为边界】',
+    '· 严禁代替其他智能体回答具体业务问题（你只负责拆解、分发、汇总）；',
+    '· 每次分发任务后，必须等待相关成员反馈，再进行下一轮动作；',
+    '· 除非收到明确指令，否则不得擅自终止或重置任务。',
+    '',
+    recentText(recentLines),
     '',
-    lines ? `最近群消息：\n${lines}` : '（群里还没有其他消息）',
+    `【当前状态】${stateText}`,
+    `用户原话：「${String(userMessage ?? '')}」`,
+    '【本轮成员反馈】',
+    feedbackText,
     '',
-    `${triggerText}：${message}`,
-    `请回复「${selfName}」的回答：`,
+    decideText,
   ].join('\n');
 }
 
-/** 是否"明确点名谁来接话"：从成员回复里解析 @（不含 @all）。 */
-export function handoffMentions(text, members) {
-  const { found, all } = mentionsIn(text, members);
-  if (all) return members.filter((m) => found.length === 0 || found.some((f) => f.id === m.id));
-  return found;
+/**
+ * 成员提示词（两种来源：用户直接 @ / 主管分派）。
+ *
+ * @param {object} opts
+ * @param {object} opts.group 群实体
+ * @param {{id:string,name:string}[]} opts.members 群成员
+ * @param {string} opts.selfId 被投递的成员 id
+ * @param {{role:string,name?:string,text:string}[]} opts.recentLines 最近群消息
+ * @param {string} opts.task 需要该成员做的事（用户原话 / 主管分派内容）
+ * @param {'user-direct'|'manager-task'} opts.mode 触发来源
+ * @returns {string}
+ */
+export function buildMemberPrompt({ group, members, selfId, recentLines, task, mode }) {
+  const self = members.find((m) => m.id === selfId);
+  const selfName = self?.name ?? '你';
+  const manager = members.find((m) => m.id === group.managerId);
+  const source = mode === 'user-direct'
+    ? '用户在群里**直接点名**让你回答，不需要等群主管分派。'
+    : `群主管「${manager?.name ?? '主管'}」把任务分派给了你（这是你的子任务）。`;
+
+  return [
+    `你在工作群「${group.name}」里，你是「${selfName}」。群成员：${memberListText(members, group.managerId)}。`,
+    source,
+    '',
+    '【本次任务】',
+    String(task ?? '').trim() || '（没有具体任务，请简短回应）',
+    '',
+    '【你的职责】',
+    '1. 只完成与你相关的部分，不要代替其他成员发言，也不要互相 @ 点名；',
+    '2. 完成后给出**简短结果反馈**（结论 / 产出 / 需要决策的点），不要长篇大论；',
+    '3. 不要向用户提问（有问题就把问题写进反馈，由群主管汇总）；',
+    '4. 只回应这一次，不主动接话。',
+    '',
+    recentText(recentLines),
+    '',
+    '请给出你的反馈：',
+  ].join('\n');
 }