jbc-dssi 1.1.7 → 1.1.8

package/package.json

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

package/vendor/groups/bridge/engine/round.js

@@ -0,0 +1,319 @@
+/**
+ * groups/bridge/engine/round.js —— 「一轮怎么跑」：投递、等待窗口、计时与超时。
+ *
+ * move-only 第一刀（2026-11-02）：从 `groups/bridge/engine.js` **原样搬来** `deliver` 与
+ * 等待窗口常量，**零逻辑改动**。协作方（会话绑定 / 结果落库 / 纯函数）一律由
+ * engine.js 注入，本文件**不引用任何同目录子模块**、也不反向 import engine.js。
+ */
+
+import { randomUUID } from 'node:crypto';
+
+/**
+ * 群任务等待窗口（2026-11-01 治本：把"240 秒硬超时"改成三段式）。
+ *
+ * 旧行为：prompt 后 240s 没等到 turn/end 就 settle({missed})，行落成「[未回应]」。
+ * 可构建/发布/上传这类长任务普遍超过 4 分钟：成员仍在执行、稍后确有回复，却已被
+ * 判"未回应"，而且结果被丢弃 —— 这就是"未回应总伴随活干完了"的根因。
+ *
+ * 新口径：
+ *   ① TURN_IDLE_TIMEOUT_MS 降级成**静默看门狗**：只观测、只记日志，绝不结算；
+ *   ② 总预算按任务类型给：普通 10 分钟、长任务（发版/构建/发布/上传…）30 分钟；
+ *   ③ 预算耗尽 ≠ 失败：落中性「（仍在执行，结果稍后补上）」占位；
+ *   ④ 占位后继续**安静跟随**该会话（不广播，避免串到下一成员的流式块），
+ *      turn/end 一到就把真实正文/用量/步数作为**同一轮的补发行**落库（回填）。
+ */
+export const TURN_IDLE_TIMEOUT_MS = 240_000;
+export const TURN_BUDGET_DEFAULT_MS = 10 * 60_000;
+export const TURN_BUDGET_LONG_MS = 30 * 60_000;
+/** 预算耗尽后还愿意等多久的补发窗口（超过就放弃回填，只保留中性占位）。 */
+export const LATE_WATCH_MAX_MS = 2 * 60 * 60_000;
+/** 长任务识别：文案里出现这些词就给长预算（纯文本判定，不做语义猜测）。 */
+const LONG_TASK_RE = /发版|发布|构建|打包|上传|部署|安装包|APK|apk|release|deploy|build|publish|npm|Gitee|gitee/;
+
+/**
+ * 按任务文案挑等待预算：长任务 30 分钟，其余 10 分钟。
+ * 纯函数（不依赖运行时），单测直接钉边界。
+ */
+export function taskBudgetMs(taskText, { defaultMs = TURN_BUDGET_DEFAULT_MS, longMs = TURN_BUDGET_LONG_MS } = {}) {
+  return LONG_TASK_RE.test(String(taskText ?? '')) ? longMs : defaultMs;
+}
+
+/**
+ * 造 `deliver`：投递一轮给一个成员，等回复完成后结算。
+ *
+ * 注入项（全部由 engine.js 提供，本文件不直接依赖它们）：
+ * - `ctx` / `log` / `broadcast`：DSH 上下文与日志/广播；
+ * - `timing`：等待窗口参数（生产用默认值；测试注入小值）；
+ * - `ensureSession(group, memberId)`：会话绑定（session.js）；
+ * - `emitLateReply` / `emitLateFailure`：迟到结果回填（settle.js）；
+ * - `assistantText` / `normalizeUsage` / `sumUsage`：纯函数。
+ *
+ * @returns {(group:object, member:object, prompt:string, attachments?:object, opts?:object) => Promise<{
+ *   text?:string, failed?:string, stillRunning?:boolean, usage?:object|null, steps?:number, stepUsages?:Array<object>}>}
+ */
+export function createDeliver({
+  ctx,
+  log,
+  broadcast,
+  timing,
+  ensureSession,
+  emitLateReply,
+  emitLateFailure,
+  assistantText,
+  normalizeUsage,
+  sumUsage,
+}) {
+  /**
+   * 投递一轮给一个成员，等回复完成后 settle。
+   *
+   * @returns {Promise<{text?:string, failed?:string, stillRunning?:boolean,
+   *   usage?:object|null, steps?:number, stepUsages?:Array<object>}>}
+   *   `stillRunning` = 总预算耗尽（任务可能还在执行，结果稍后以补发行回填）。
+   *   `stepUsages` = 本轮每一步的用量（每一步一条，按到达顺序）；它和 `usage`
+   *   （各步求和）一起进房间日志，供读侧还原与兼容老客户端。
+   */
+  return function deliver(group, member, prompt, attachments = {}, opts = {}) {
+    const budgetMs = typeof opts.budgetMs === 'number' ? opts.budgetMs : timing.defaultBudgetMs;
+    const roundNo = opts.round?.rounds ?? 0;
+    return new Promise((resolve) => {
+      let settled = false;
+      let stillRunning = false;
+      let lateWait = false;
+      let followClosed = false;
+      let idleTimer = null;
+      let budgetTimer = null;
+      let lateTimer = null;
+      /*
+       * ★ 结算判据：等「整个 turn 结束」，不是「第一条 assistant/message」。
+       *
+       * 2026-10-30 真机实测（解压群会话事件逐条核对）：一个 turn 会被拆成多个 step，
+       * **每一步都发一条 assistant/message**。例如用户说「早上好」那一轮：
+       *
+       *   step1..8  blocks=[reasoning, tool-call(bash)]   ← 没有 text
+       *   step9     blocks=[reasoning, text(806)]         ← 这才是回答
+       *   turn/end  reason={kind:'completed'}
+       *
+       * 旧实现遇到 step1 就 settle 并 ac.abort()：assistantText 取不到 text →
+       * 落成「[未回应]」，后面 8 步全被掐掉。用户看到的就是
+       * 「明明有输出、有思维过程、有用量（74K tok），却显示未回应」。
+       *
+       * 现在：轮内**累积**最后一条带正文的消息，只在 turn/end 结算。
+       */
+      let prompted = false;
+      let minTurn = null;
+      let lastText = '';
+      /*
+       * 本轮用量 = 各 step 的 usage **累加**（见 [sumUsage]）。
+       *
+       * 2026-10-31 之前这里是 `lastUsage`（只留最后一条 assistant/message），
+       * 于是「共 N 步」配的是"最后一步"的 token，步数越多的轮次少算越多。
+       */
+      let turnUsage = null;
+      /*
+       * 本轮**逐步**用量（2026-11-01 新增）：每一步一条，与 turnUsage 同源。
+       *
+       * 为什么存这个：旧存储只留聚合值，刷新/重进后无法还原「每一步花了多少」，
+       * 历史记录也就永远只能信当时写下的那个数。逐步入库后，读侧可以用它求和还原 ——
+       * 面板在实时、刷新、重进、换端任何时刻都是同一份数据的计算结果。
+       */
+      const stepUsages = [];
+      /*
+       * 「共 N 步」的账：turn → 这一轮出现过的 step 号集合。
+       *
+       * 与单聊**同一个算法**（ChatScreen 的 `turnStepNums`）：assistant/message
+       * 每个 step 发一条，收集本轮的 step 号去重后求个数；重试时同一个 step 可能
+       * 重复到达，用集合才不会多算。
+       */
+      const turnStepNums = new Map();
+      let lastTurn = -1;
+
+      const clearIdle = () => {
+        if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; }
+      };
+      const settle = (result) => {
+        if (settled) return;
+        settled = true;
+        if (budgetTimer) { clearTimeout(budgetTimer); budgetTimer = null; }
+        clearIdle();
+        resolve(result);
+      };
+      /*
+       * 静默看门狗：任意帧到达就重置；静默只记日志，**绝不结算**。
+       * （长命令执行期间可能长时间没有事件，那不等于失联。）
+       */
+      const noteActivity = () => {
+        if (settled) return;
+        clearIdle();
+        idleTimer = setTimeout(() => {
+          log?.(`[groups] ${member.name} 静默 ${timing.idleMs}ms，任务可能仍在执行（不结算、不判未回应）`);
+        }, timing.idleMs);
+      };
+      let sessionId = null;
+      (async () => {
+        try {
+          sessionId = await ensureSession(group, member.id);
+        } catch (err) {
+          settle({ failed: String(err?.message ?? err) });
+          return;
+        }
+
+        const ac = new AbortController();
+        const stream = ctx.sessionController.follow(
+          { address: { kind: 'session', sessionId }, assistantStream: true, maxMessages: 1 },
+          ac.signal,
+        );
+        void (async () => {
+          try {
+            for await (const frame of stream) {
+              /*
+               * 本轮已 settle（拿到 assistant/message / 被判失败）就立刻停手。
+               *
+               * ★ 原来只在 followClosed（投递失败）时 break，settle 之后若流里还有
+               *   缓冲帧（end、尾包）会继续广播 room_stream。而那些帧到达手机时，
+               *   下一位成员往往已经开始说了 —— 手机侧流式块是「每群一个槽位」，
+               *   于是上一位的尾巴被画进了下一位的块里，表现为
+               *   「上一成员没有输出，下一成员的话就来了」（用户实测原话）。
+               */
+              // 成功/明确失败才停；预算耗尽后进入"补发观察"，继续安静跟随却不再广播
+              if (followClosed || (settled && !lateWait)) break;
+              noteActivity();
+              // 群消息流式增量：与智能体单聊同一推送机制 —— assistant-stream 帧原样
+              // 广播给手机（room_stream），手机侧用单聊同款 reduceLive 边收边画；
+              // 完整文本仍由 assistant/message → settle → room_line 落盘（下方处理）。
+              if (frame?.type === 'assistant-stream') {
+                if (!settled) {
+                  broadcast?.({ type: 'room_stream', groupId: group.id, memberId: member.id, name: member.name, frame });
+                }
+                continue;
+              }
+              if (frame?.type === 'event') {
+                const event = frame.event;
+                const data = event?.data ?? {};
+                /*
+                 * prompt 之前 follow 会先回放历史（maxMessages 条）——
+                 * 那些事件属于上一轮，绝不能拿来结算本轮。
+                 */
+                if (!prompted) continue;
+                // 回放的残余事件也可能晚到：只认本轮及之后的 turn。
+                if (minTurn !== null && typeof data.turn === 'number' && data.turn < minTurn) continue;
+
+                if (typeof data.turn === 'number') lastTurn = data.turn;
+                if (event?.type === 'turn/start') {
+                  if (minTurn === null && typeof data.turn === 'number') minTurn = data.turn;
+                } else if (event?.type === 'assistant/message') {
+                  // 工具调用那几步没有 text，不能拿它们当回答；有正文才覆盖。
+                  const text = assistantText(event);
+                  if (text) lastText = text;
+                  /*
+                   * 步数：**所有** assistant/message 都要记，包括只调工具、不画块的那几步
+                   * （与单聊一致 —— token 大头正是这些步骤花掉的）。
+                   */
+                  const step = typeof data.step === 'number' ? data.step : -1;
+                  const usage = normalizeUsage(data.usage);
+                  if (usage) {
+                    /*
+                     * 逐步入库：步号 + 这一步的五个 token 字段。
+                     * 同一步重试会各存一条（用量按 attempt 累加，与单聊/Web 一致），
+                     * 步数仍由 turnStepNums 按 step 号去重，两者互不影响。
+                     */
+                    stepUsages.push({ step, ...usage });
+                    turnUsage = sumUsage(turnUsage, usage);
+                  }
+                  if (step >= 0 && typeof data.turn === 'number') {
+                    if (!turnStepNums.has(data.turn)) turnStepNums.set(data.turn, new Set());
+                    turnStepNums.get(data.turn).add(step);
+                  }
+                } else if (event?.type === 'turn/end') {
+                  const kind = data.reason?.kind;
+                  /*
+                   * 本轮步数：取 turn/end 指向的那一轮（拿不到就退回最后见过的一轮）。
+                   * 0 = 没统计到（老版本插件 / 事件里没带 step）→ 手机侧整段不显示。
+                   */
+                  const endTurn = typeof data.turn === 'number' ? data.turn : lastTurn;
+                  const steps = turnStepNums.get(endTurn)?.size ?? 0;
+                  if (kind && kind !== 'completed') {
+                    const failed = String(data.reason?.message ?? kind);
+                    if (settled && lateWait) emitLateFailure(group, member, failed, roundNo);
+                    else settle({ failed });
+                  } else if (settled && lateWait) {
+                    /*
+                     * 预算耗尽后迟到的真实结果 → 作为**同一轮的补发行**落库（回填，不丢弃）。
+                     * 这是"不用 240 秒误判长任务"的最后一环。
+                     */
+                    emitLateReply(group, member, { text: lastText, usage: turnUsage, steps, stepUsages }, roundNo);
+                    followClosed = true;
+                  } else {
+                    settle({ text: lastText, usage: turnUsage, steps, stepUsages });
+                  }
+                  if (lateTimer) { clearTimeout(lateTimer); lateTimer = null; }
+                  ac.abort();
+                } else if (event?.type === 'turn/error' || event?.type === 'turn/failed') {
+                  settle({ failed: String(event?.data?.error?.message ?? '会话失败') });
+                }
+              }
+            }
+          } catch (err) {
+            if (!settled && !followClosed) settle({ failed: String(err?.message ?? err) });
+          }
+        })();
+
+        void (async () => {
+          try {
+            await new Promise((resolveNext) => setTimeout(resolveNext, 10));
+            /*
+             * 投递内容 = prompt 文字，后面按顺序挂上附件 part。
+             *
+             * 形状与单聊 PROMPT 完全一致：{type:'image', mediaType, data} /
+             * {type:'file', receiptId}。这样成员用的就是同一套模型能力。
+             */
+            const content = [{ type: 'text', text: prompt }];
+            for (const image of (attachments?.images ?? [])) {
+              content.push({
+                type: 'image',
+                mediaType: typeof image?.mediaType === 'string' ? image.mediaType : 'image/jpeg',
+                data: image.data,
+              });
+            }
+            for (const file of (attachments?.files ?? [])) {
+              content.push({ type: 'file', receiptId: file.receiptId });
+            }
+            await ctx.sessionController.prompt(
+              {
+                requestId: randomUUID(),
+                sessionId,
+                mode: 'queue',
+                content,
+              },
+              AbortSignal.timeout(30_000),
+            );
+            // 请求已进队列：此后到达的事件才属于本轮（之前的都是历史回放）。
+            prompted = true;
+            noteActivity();
+            /*
+             * 总预算（任务类型决定 10 / 30 分钟）。耗尽 ≠ 失败：
+             * 落中性「（仍在执行，结果稍后补上）」占位，并继续安静跟随等真实结果回填。
+             */
+            budgetTimer = setTimeout(() => {
+              if (settled) return;
+              lateWait = true;
+              stillRunning = true;
+              settle({ stillRunning: true });
+              lateTimer = setTimeout(() => {
+                lateWait = false;
+                followClosed = true;
+                ac.abort();
+                log?.(`[groups] ${member.name} 补发窗口 ${timing.lateMaxMs}ms 内仍未结束，放弃回填（中性占位保留）`);
+              }, timing.lateMaxMs);
+            }, budgetMs);
+          } catch (err) {
+            if (!settled) {
+              followClosed = true;
+              ac.abort();
+              settle({ failed: String(err?.message ?? err) });
+            }
+          }
+        })();
+      })();
+    });
+  };
+}

package/vendor/groups/bridge/engine/session.js

@@ -0,0 +1,33 @@
+/**
+ * groups/bridge/engine/session.js —— 「任务/成员怎么绑定到 DSH Session」。
+ *
+ * move-only 第一刀（2026-11-02）：从 `groups/bridge/engine.js` **原样搬来**
+ * `ensureGroupSession`，**零逻辑改动**。ctx/dssAgent 由 engine.js 注入；
+ * 本文件**不引用任何同目录子模块**、也不反向 import engine.js。
+ */
+
+/**
+ * 造「群会话绑定器」：懒创建并持久化 `memberId -> sessionId` 映射。
+ *
+ * @param {object} deps
+ * @param {object} deps.ctx DSH 上下文（仅用公开方法）
+ * @param {object} deps.state 群状态（groupSessions）
+ * @param {object} deps.dssAgent dssAgent 引擎（createSession 公开方法）
+ * @param {Function} deps.save 持久化（串行写）
+ */
+export function createSessionBinder({ ctx, state, dssAgent, save }) {
+  /** 群会话：懒创建并持久化映射（memberId -> sessionId）。 */
+  async function ensureGroupSession(group, memberId) {
+    const map = (state.groupSessions[group.id] ??= {});
+    if (map[memberId]) return map[memberId];
+    const { sessionId } = await dssAgent.createSession({
+      entityId: memberId,
+      title: `[群]${group.name}`,
+    });
+    map[memberId] = sessionId;
+    void save?.();
+    return sessionId;
+  }
+
+  return { ensureGroupSession };
+}

package/vendor/groups/bridge/engine/settle.js

@@ -0,0 +1,122 @@
+/**
+ * groups/bridge/engine/settle.js —— 「这轮怎么收口」：房间行落库、迟到回填、读侧快照。
+ *
+ * move-only 第一刀（2026-11-02）：从 `groups/bridge/engine.js` **原样搬来**
+ * `emitLine` / `emitLateReply` / `emitLateFailure` / `emitReplyLine` / `roomSnapshot`，
+ * **零逻辑改动**。依赖（state/save/broadcast/log/now/aggregateStepUsages）全部由
+ * engine.js 注入；本文件**不引用任何同目录子模块**、也不反向 import engine.js。
+ */
+
+/** 房间日志最多保留条数（超出丢最旧，防无限膨胀）。 */
+const ROOM_LOG_MAX = 60;
+
+/**
+ * 造「房间行读写器」。
+ *
+ * @param {object} deps
+ * @param {object} deps.state 群状态（rooms）
+ * @param {Function} deps.save 持久化（串行写）
+ * @param {Function} deps.broadcast 群事件广播
+ * @param {Function} deps.log 日志
+ * @param {Function} deps.now 时钟（默认 Date.now）
+ * @param {Function} deps.aggregateStepUsages 逐步用量求和（engine.js 注入）
+ */
+export function createSettler({ state, save, broadcast, log, now = () => Date.now(), aggregateStepUsages }) {
+  /**
+   * 追加一行到房间日志。
+   *
+   * ★ seq 必须**单调递增、永不复用**。
+   *
+   * 过去拿「数组长度」当 seq，而房间日志满 ROOM_LOG_MAX 后要 shift 掉最旧的 ——
+   * 长度从此恒定在 60，于是第 61 条之后每条 seq 都是 60。手机侧 LazyColumn
+   * 以 seq 作 key，重复 key 直接崩：
+   *   `IllegalArgumentException: Key "60" was already used`（2026-10-29 真机实测）。
+   *
+   * 改成「上一条 seq + 1」：与长度彻底解耦，truncate 多少次都不会回退。
+   * 调用方原先传的 seq 一律忽略（统一在这里分配，避免两处算法漂移）。
+   */
+  function emitLine(groupId, line) {
+    const room = (state.rooms[groupId] ??= []);
+    const last = room[room.length - 1];
+    const seq = (typeof last?.seq === 'number' ? last.seq : -1) + 1;
+    const entry = { ...line, seq };
+    room.push(entry);
+    while (room.length > ROOM_LOG_MAX) room.shift();
+    void save?.();
+    broadcast?.({ type: 'room_line', groupId, line: entry });
+  }
+
+  /** 预算耗尽后迟到的真实回复：作为**同一轮的补发行**追加（不改已有行、不丢结果）。 */
+  function emitLateReply(group, member, result, roundNo) {
+    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,
+      stepUsages: Array.isArray(result.stepUsages) && result.stepUsages.length > 0 ? result.stepUsages : undefined,
+      late: true,
+      round: roundNo,
+    });
+    log?.(`[groups] ${member.name} 的迟到回复已补发（round=${roundNo}）`);
+  }
+
+  /** 预算耗尽后迟到的明确失败：只有明确失败才报错（中性"仍在执行"不报失败）。 */
+  function emitLateFailure(group, member, failed, roundNo) {
+    emitLine(group.id, {
+      at: now(), role: 'system', name: member.name,
+      text: `${member.name} 回应失败：${failed}`,
+      late: true,
+      round: roundNo,
+    });
+  }
+
+  function emitReplyLine(group, round, member, result) {
+    const trimmed = String(result.text ?? '').trim();
+    /*
+     * 状态口径分离（2026-11-01）：预算耗尽 → 中性「（仍在执行…）」，**不是**未回应；
+     * 「[未回应]」只留给"正常结束但整轮没有正文"（纯工具调用）这种诚实兜底。
+     */
+    const text = trimmed || (result.stillRunning ? '（仍在执行，结果稍后补上）' : '[未回应]');
+    emitLine(group.id, {
+      at: now(),
+      role: 'member',
+      memberId: member.id,
+      name: member.name,
+      text,
+      usage: result.usage ?? null,
+      steps: result.steps ?? 0,
+      // 只有真的收到过 usage 才写这个字段；否则 JSON 里不出现（= 老格式，读侧回落）
+      stepUsages: Array.isArray(result.stepUsages) && result.stepUsages.length > 0
+        ? result.stepUsages
+        : undefined,
+      // 中性"仍在执行"标记（老 app 忽略未知字段；新读侧/排查可据此区分）
+      stillRunning: result.stillRunning === true ? true : undefined,
+      round: round?.rounds ?? 0,
+    });
+    round.totalTurns += 1;
+    return text;
+  }
+
+  /**
+   * 打开群聊页时拉房间历史。
+   *
+   * 【读侧口径（2026-11-01）】
+   *   带 `stepUsages` 的新记录：用量由逐步数据**当场求和**再下发 —— 刷新/重进拿到的
+   *     值和实时那一刻完全同源（这份和也是 `usage` 字段的来源，二者恒等）。
+   *   没有 `stepUsages` 的旧记录：**原样返回**，显示当时写下的历史值。按负责人决定
+   *     历史不救 —— 这里不猜、不补 0、不拿别的字段假装重算。
+   */
+  function roomSnapshot(group) {
+    return (state.rooms[group.id] ?? []).slice(-ROOM_LOG_MAX).map((line) => {
+      if (!Array.isArray(line?.stepUsages) || line.stepUsages.length === 0) return line;
+      const usage = aggregateStepUsages(line.stepUsages);
+      return usage ? { ...line, usage } : line;
+    });
+  }
+
+  return { emitLine, emitLateReply, emitLateFailure, emitReplyLine, roomSnapshot };
+}

package/vendor/groups/bridge/engine.js

@@ -17,44 +17,24 @@
  * 按主管回复里的 @ 点名分发下一批。
  *
  * 不依赖 DSH 内部实现：会话操作全部走 ctx.sessionController 的公开方法。
+ *
+ * ── 结构（2026-11-02 巨石拆除第一刀，move-only，导出未变）───────────────
+ * 本文件变「门面 + 编排」；实现按职责搬进同目录子模块，子模块之间零引用，
+ * 依赖一律由这里注入：
+ *   - `engine/round.js`  一轮怎么跑：投递、静默看门狗、预算/补发窗口（`deliver`）
+ *   - `engine/settle.js` 一轮怎么收口：房间行落库、迟到回填、读侧快照
+ *   - `engine/session.js` 成员会话绑定（懒创建 + 持久化映射）
+ * 对外 API 保持一字不变：`createRoundEngine`、`taskBudgetMs`（后者从 round.js 转发）。
  */
 
-import { randomUUID } from 'node:crypto';
 import { mentionsIn } from './mentions.js';
 import { buildManagerPrompt, buildMemberPrompt } from './prompt.js';
+import { createDeliver, taskBudgetMs, TURN_IDLE_TIMEOUT_MS, TURN_BUDGET_DEFAULT_MS, TURN_BUDGET_LONG_MS, LATE_WATCH_MAX_MS } from './engine/round.js';
+import { createSettler } from './engine/settle.js';
+import { createSessionBinder } from './engine/session.js';
 
-/** 房间日志最多保留条数（超出丢最旧，防无限膨胀）。 */
-const ROOM_LOG_MAX = 60;
-
-/**
- * 群任务等待窗口（2026-11-01 治本：把"240 秒硬超时"改成三段式）。
- *
- * 旧行为：prompt 后 240s 没等到 turn/end 就 settle({missed})，行落成「[未回应]」。
- * 可构建/发布/上传这类长任务普遍超过 4 分钟：成员仍在执行、稍后确有回复，却已被
- * 判"未回应"，而且结果被丢弃 —— 这就是"未回应总伴随活干完了"的根因。
- *
- * 新口径：
- *   ① TURN_IDLE_TIMEOUT_MS 降级成**静默看门狗**：只观测、只记日志，绝不结算；
- *   ② 总预算按任务类型给：普通 10 分钟、长任务（发版/构建/发布/上传…）30 分钟；
- *   ③ 预算耗尽 ≠ 失败：落中性「（仍在执行，结果稍后补上）」占位；
- *   ④ 占位后继续**安静跟随**该会话（不广播，避免串到下一成员的流式块），
- *      turn/end 一到就把真实正文/用量/步数作为**同一轮的补发行**落库（回填）。
- */
-const TURN_IDLE_TIMEOUT_MS = 240_000;
-const TURN_BUDGET_DEFAULT_MS = 10 * 60_000;
-const TURN_BUDGET_LONG_MS = 30 * 60_000;
-/** 预算耗尽后还愿意等多久的补发窗口（超过就放弃回填，只保留中性占位）。 */
-const LATE_WATCH_MAX_MS = 2 * 60 * 60_000;
-/** 长任务识别：文案里出现这些词就给长预算（纯文本判定，不做语义猜测）。 */
-const LONG_TASK_RE = /发版|发布|构建|打包|上传|部署|安装包|APK|apk|release|deploy|build|publish|npm|Gitee|gitee/;
+export { taskBudgetMs };
 
-/**
- * 按任务文案挑等待预算：长任务 30 分钟，其余 10 分钟。
- * 纯函数（不依赖运行时），单测直接钉边界。
- */
-export function taskBudgetMs(taskText, { defaultMs = TURN_BUDGET_DEFAULT_MS, longMs = TURN_BUDGET_LONG_MS } = {}) {
-  return LONG_TASK_RE.test(String(taskText ?? '')) ? longMs : defaultMs;
-}
 /**
  * 轮次上限（最高红线，用户定稿）：
  * 「分发任务 → 接收反馈」算 1 轮；1~4 轮内可提前结束；第 5 轮收齐反馈后必须强制汇报，
@@ -172,372 +152,34 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast,
   const budgetFor = (taskText) =>
     taskBudgetMs(taskText, { defaultMs: timing.defaultBudgetMs, longMs: timing.longBudgetMs });
 
-  /**
-   * 追加一行到房间日志。
-   *
-   * ★ seq 必须**单调递增、永不复用**。
-   *
-   * 过去拿「数组长度」当 seq，而房间日志满 ROOM_LOG_MAX 后要 shift 掉最旧的 ——
-   * 长度从此恒定在 60，于是第 61 条之后每条 seq 都是 60。手机侧 LazyColumn
-   * 以 seq 作 key，重复 key 直接崩：
-   *   `IllegalArgumentException: Key "60" was already used`（2026-10-29 真机实测）。
-   *
-   * 改成「上一条 seq + 1」：与长度彻底解耦，truncate 多少次都不会回退。
-   * 调用方原先传的 seq 一律忽略（统一在这里分配，避免两处算法漂移）。
-   */
-  function emitLine(groupId, line) {
-    const room = (state.rooms[groupId] ??= []);
-    const last = room[room.length - 1];
-    const seq = (typeof last?.seq === 'number' ? last.seq : -1) + 1;
-    const entry = { ...line, seq };
-    room.push(entry);
-    while (room.length > ROOM_LOG_MAX) room.shift();
-    void save?.();
-    broadcast?.({ type: 'room_line', groupId, line: entry });
-  }
-
-  /** 群会话：懒创建并持久化映射（memberId -> sessionId）。 */
-  async function ensureGroupSession(group, memberId) {
-    const map = (state.groupSessions[group.id] ??= {});
-    if (map[memberId]) return map[memberId];
-    const { sessionId } = await dssAgent.createSession({
-      entityId: memberId,
-      title: `[群]${group.name}`,
-    });
-    map[memberId] = sessionId;
-    void save?.();
-    return sessionId;
-  }
+  /* ── 子模块装配（依赖由门面注入；子模块之间零引用）── */
+  const { emitLine, emitLateReply, emitLateFailure, emitReplyLine, roomSnapshot } = createSettler({
+    state,
+    save,
+    broadcast,
+    log,
+    now,
+    aggregateStepUsages,
+  });
+  const { ensureGroupSession } = createSessionBinder({ ctx, state, dssAgent, save });
+  const deliver = createDeliver({
+    ctx,
+    log,
+    broadcast,
+    timing,
+    ensureSession: ensureGroupSession,
+    emitLateReply,
+    emitLateFailure,
+    assistantText,
+    normalizeUsage,
+    sumUsage,
+  });
 
   /** 最近群消息（含刚落的用户行/成员行），给 prompt 做上下文。 */
   function recentLinesOf(group) {
     return (state.rooms[group.id] ?? []).slice(-RECENT_LINES_MAX);
   }
 
-  /**
-   * 投递一轮给一个成员，等回复完成后 settle。
-   *
-   * @returns {Promise<{text?:string, failed?:string, stillRunning?:boolean,
-   *   usage?:object|null, steps?:number, stepUsages?:Array<object>}>}
-   *   `stillRunning` = 总预算耗尽（任务可能还在执行，结果稍后以补发行回填）。
-   *   `stepUsages` = 本轮每一步的用量（每一步一条，按到达顺序）；它和 `usage`
-   *   （各步求和）一起进房间日志，供读侧还原与兼容老客户端。
-   */
-  function deliver(group, member, prompt, attachments = {}, opts = {}) {
-    const budgetMs = typeof opts.budgetMs === 'number' ? opts.budgetMs : timing.defaultBudgetMs;
-    const roundNo = opts.round?.rounds ?? 0;
-    return new Promise((resolve) => {
-      let settled = false;
-      let stillRunning = false;
-      let lateWait = false;
-      let followClosed = false;
-      let idleTimer = null;
-      let budgetTimer = null;
-      let lateTimer = null;
-      /*
-       * ★ 结算判据：等「整个 turn 结束」，不是「第一条 assistant/message」。
-       *
-       * 2026-10-30 真机实测（解压群会话事件逐条核对）：一个 turn 会被拆成多个 step，
-       * **每一步都发一条 assistant/message**。例如用户说「早上好」那一轮：
-       *
-       *   step1..8  blocks=[reasoning, tool-call(bash)]   ← 没有 text
-       *   step9     blocks=[reasoning, text(806)]         ← 这才是回答
-       *   turn/end  reason={kind:'completed'}
-       *
-       * 旧实现遇到 step1 就 settle 并 ac.abort()：assistantText 取不到 text →
-       * 落成「[未回应]」，后面 8 步全被掐掉。用户看到的就是
-       * 「明明有输出、有思维过程、有用量（74K tok），却显示未回应」。
-       *
-       * 现在：轮内**累积**最后一条带正文的消息，只在 turn/end 结算。
-       */
-      let prompted = false;
-      let minTurn = null;
-      let lastText = '';
-      /*
-       * 本轮用量 = 各 step 的 usage **累加**（见 [sumUsage]）。
-       *
-       * 2026-10-31 之前这里是 `lastUsage`（只留最后一条 assistant/message），
-       * 于是「共 N 步」配的是"最后一步"的 token，步数越多的轮次少算越多。
-       */
-      let turnUsage = null;
-      /*
-       * 本轮**逐步**用量（2026-11-01 新增）：每一步一条，与 turnUsage 同源。
-       *
-       * 为什么存这个：旧存储只留聚合值，刷新/重进后无法还原「每一步花了多少」，
-       * 历史记录也就永远只能信当时写下的那个数。逐步入库后，读侧可以用它求和还原 ——
-       * 面板在实时、刷新、重进、换端任何时刻都是同一份数据的计算结果。
-       */
-      const stepUsages = [];
-      /*
-       * 「共 N 步」的账：turn → 这一轮出现过的 step 号集合。
-       *
-       * 与单聊**同一个算法**（ChatScreen 的 `turnStepNums`）：assistant/message
-       * 每个 step 发一条，收集本轮的 step 号去重后求个数；重试时同一个 step 可能
-       * 重复到达，用集合才不会多算。
-       */
-      const turnStepNums = new Map();
-      let lastTurn = -1;
-
-      const clearIdle = () => {
-        if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; }
-      };
-      const settle = (result) => {
-        if (settled) return;
-        settled = true;
-        if (budgetTimer) { clearTimeout(budgetTimer); budgetTimer = null; }
-        clearIdle();
-        resolve(result);
-      };
-      /*
-       * 静默看门狗：任意帧到达就重置；静默只记日志，**绝不结算**。
-       * （长命令执行期间可能长时间没有事件，那不等于失联。）
-       */
-      const noteActivity = () => {
-        if (settled) return;
-        clearIdle();
-        idleTimer = setTimeout(() => {
-          log?.(`[groups] ${member.name} 静默 ${timing.idleMs}ms，任务可能仍在执行（不结算、不判未回应）`);
-        }, timing.idleMs);
-      };
-      let sessionId = null;
-      (async () => {
-        try {
-          sessionId = await ensureGroupSession(group, member.id);
-        } catch (err) {
-          settle({ failed: String(err?.message ?? err) });
-          return;
-        }
-
-        const ac = new AbortController();
-        const stream = ctx.sessionController.follow(
-          { address: { kind: 'session', sessionId }, assistantStream: true, maxMessages: 1 },
-          ac.signal,
-        );
-        void (async () => {
-          try {
-            for await (const frame of stream) {
-              /*
-               * 本轮已 settle（拿到 assistant/message / 被判失败）就立刻停手。
-               *
-               * ★ 原来只在 followClosed（投递失败）时 break，settle 之后若流里还有
-               *   缓冲帧（end、尾包）会继续广播 room_stream。而那些帧到达手机时，
-               *   下一位成员往往已经开始说了 —— 手机侧流式块是「每群一个槽位」，
-               *   于是上一位的尾巴被画进了下一位的块里，表现为
-               *   「上一成员没有输出，下一成员的话就来了」（用户实测原话）。
-               */
-              // 成功/明确失败才停；预算耗尽后进入"补发观察"，继续安静跟随却不再广播
-              if (followClosed || (settled && !lateWait)) break;
-              noteActivity();
-              // 群消息流式增量：与智能体单聊同一推送机制 —— assistant-stream 帧原样
-              // 广播给手机（room_stream），手机侧用单聊同款 reduceLive 边收边画；
-              // 完整文本仍由 assistant/message → settle → room_line 落盘（下方处理）。
-              if (frame?.type === 'assistant-stream') {
-                if (!settled) {
-                  broadcast?.({ type: 'room_stream', groupId: group.id, memberId: member.id, name: member.name, frame });
-                }
-                continue;
-              }
-              if (frame?.type === 'event') {
-                const event = frame.event;
-                const data = event?.data ?? {};
-                /*
-                 * prompt 之前 follow 会先回放历史（maxMessages 条）——
-                 * 那些事件属于上一轮，绝不能拿来结算本轮。
-                 */
-                if (!prompted) continue;
-                // 回放的残余事件也可能晚到：只认本轮及之后的 turn。
-                if (minTurn !== null && typeof data.turn === 'number' && data.turn < minTurn) continue;
-
-                if (typeof data.turn === 'number') lastTurn = data.turn;
-                if (event?.type === 'turn/start') {
-                  if (minTurn === null && typeof data.turn === 'number') minTurn = data.turn;
-                } else if (event?.type === 'assistant/message') {
-                  // 工具调用那几步没有 text，不能拿它们当回答；有正文才覆盖。
-                  const text = assistantText(event);
-                  if (text) lastText = text;
-                  /*
-                   * 步数：**所有** assistant/message 都要记，包括只调工具、不画块的那几步
-                   * （与单聊一致 —— token 大头正是这些步骤花掉的）。
-                   */
-                  const step = typeof data.step === 'number' ? data.step : -1;
-                  const usage = normalizeUsage(data.usage);
-                  if (usage) {
-                    /*
-                     * 逐步入库：步号 + 这一步的五个 token 字段。
-                     * 同一步重试会各存一条（用量按 attempt 累加，与单聊/Web 一致），
-                     * 步数仍由 turnStepNums 按 step 号去重，两者互不影响。
-                     */
-                    stepUsages.push({ step, ...usage });
-                    turnUsage = sumUsage(turnUsage, usage);
-                  }
-                  if (step >= 0 && typeof data.turn === 'number') {
-                    if (!turnStepNums.has(data.turn)) turnStepNums.set(data.turn, new Set());
-                    turnStepNums.get(data.turn).add(step);
-                  }
-                } else if (event?.type === 'turn/end') {
-                  const kind = data.reason?.kind;
-                  /*
-                   * 本轮步数：取 turn/end 指向的那一轮（拿不到就退回最后见过的一轮）。
-                   * 0 = 没统计到（老版本插件 / 事件里没带 step）→ 手机侧整段不显示。
-                   */
-                  const endTurn = typeof data.turn === 'number' ? data.turn : lastTurn;
-                  const steps = turnStepNums.get(endTurn)?.size ?? 0;
-                  if (kind && kind !== 'completed') {
-                    const failed = String(data.reason?.message ?? kind);
-                    if (settled && lateWait) emitLateFailure(group, member, failed, roundNo);
-                    else settle({ failed });
-                  } else if (settled && lateWait) {
-                    /*
-                     * 预算耗尽后迟到的真实结果 → 作为**同一轮的补发行**落库（回填，不丢弃）。
-                     * 这是"不用 240 秒误判长任务"的最后一环。
-                     */
-                    emitLateReply(group, member, { text: lastText, usage: turnUsage, steps, stepUsages }, roundNo);
-                    followClosed = true;
-                  } else {
-                    settle({ text: lastText, usage: turnUsage, steps, stepUsages });
-                  }
-                  if (lateTimer) { clearTimeout(lateTimer); lateTimer = null; }
-                  ac.abort();
-                } else if (event?.type === 'turn/error' || event?.type === 'turn/failed') {
-                  settle({ failed: String(event?.data?.error?.message ?? '会话失败') });
-                }
-              }
-            }
-          } catch (err) {
-            if (!settled && !followClosed) settle({ failed: String(err?.message ?? err) });
-          }
-        })();
-
-        void (async () => {
-          try {
-            await new Promise((resolveNext) => setTimeout(resolveNext, 10));
-            /*
-             * 投递内容 = prompt 文字，后面按顺序挂上附件 part。
-             *
-             * 形状与单聊 PROMPT 完全一致：{type:'image', mediaType, data} /
-             * {type:'file', receiptId}。这样成员用的就是同一套模型能力。
-             */
-            const content = [{ type: 'text', text: prompt }];
-            for (const image of (attachments?.images ?? [])) {
-              content.push({
-                type: 'image',
-                mediaType: typeof image?.mediaType === 'string' ? image.mediaType : 'image/jpeg',
-                data: image.data,
-              });
-            }
-            for (const file of (attachments?.files ?? [])) {
-              content.push({ type: 'file', receiptId: file.receiptId });
-            }
-            await ctx.sessionController.prompt(
-              {
-                requestId: randomUUID(),
-                sessionId,
-                mode: 'queue',
-                content,
-              },
-              AbortSignal.timeout(30_000),
-            );
-            // 请求已进队列：此后到达的事件才属于本轮（之前的都是历史回放）。
-            prompted = true;
-            noteActivity();
-            /*
-             * 总预算（任务类型决定 10 / 30 分钟）。耗尽 ≠ 失败：
-             * 落中性「（仍在执行，结果稍后补上）」占位，并继续安静跟随等真实结果回填。
-             */
-            budgetTimer = setTimeout(() => {
-              if (settled) return;
-              lateWait = true;
-              stillRunning = true;
-              settle({ stillRunning: true });
-              lateTimer = setTimeout(() => {
-                lateWait = false;
-                followClosed = true;
-                ac.abort();
-                log?.(`[groups] ${member.name} 补发窗口 ${timing.lateMaxMs}ms 内仍未结束，放弃回填（中性占位保留）`);
-              }, timing.lateMaxMs);
-            }, budgetMs);
-          } catch (err) {
-            if (!settled) {
-              followClosed = true;
-              ac.abort();
-              settle({ failed: String(err?.message ?? err) });
-            }
-          }
-        })();
-      })();
-    });
-  }
-
-  /**
-   * 把一次投递的结果落成房间行（成员/主管同一套：手机侧按 memberId 显示名字与主管标）。
-   *
-   * 房间行里的「本轮用量」有两种格式，**读侧必须都认**：
-   *
-   *   旧格式（2026-10-31 及以前落盘的行，只保留聚合值、无法重算）：
-   *     { usage: {inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, totalTokens}, steps: 10 }
-   *   新格式（2026-11-01 起，多一个逐步数组）：
-   *     { usage: {...恒等于逐步求和...}, steps: 10,
-   *       stepUsages: [{ step: 1, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, totalTokens }, ...] }
-   *
-   * `usage` 新格式里照写：给还没升级的老手机读（它们只认这个字段）。
-   * 新手机的 GroupStore 优先用 `stepUsages` 求和 —— 刷新/重进后与实时同源。
-   * 旧行没有 `stepUsages`：读侧原样显示历史值，不补 0、不重算、不报错（历史不救）。
-   */
-  /** 预算耗尽后迟到的真实回复：作为**同一轮的补发行**追加（不改已有行、不丢结果）。 */
-  function emitLateReply(group, member, result, roundNo) {
-    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,
-      stepUsages: Array.isArray(result.stepUsages) && result.stepUsages.length > 0 ? result.stepUsages : undefined,
-      late: true,
-      round: roundNo,
-    });
-    log?.(`[groups] ${member.name} 的迟到回复已补发（round=${roundNo}）`);
-  }
-
-  /** 预算耗尽后迟到的明确失败：只有明确失败才报错（中性"仍在执行"不报失败）。 */
-  function emitLateFailure(group, member, failed, roundNo) {
-    emitLine(group.id, {
-      at: now(), role: 'system', name: member.name,
-      text: `${member.name} 回应失败：${failed}`,
-      late: true,
-      round: roundNo,
-    });
-  }
-
-  function emitReplyLine(group, round, member, result) {
-    const trimmed = String(result.text ?? '').trim();
-    /*
-     * 状态口径分离（2026-11-01）：预算耗尽 → 中性「（仍在执行…）」，**不是**未回应；
-     * 「[未回应]」只留给"正常结束但整轮没有正文"（纯工具调用）这种诚实兜底。
-     */
-    const text = trimmed || (result.stillRunning ? '（仍在执行，结果稍后补上）' : '[未回应]');
-    emitLine(group.id, {
-      at: now(),
-      role: 'member',
-      memberId: member.id,
-      name: member.name,
-      text,
-      usage: result.usage ?? null,
-      steps: result.steps ?? 0,
-      // 只有真的收到过 usage 才写这个字段；否则 JSON 里不出现（= 老格式，读侧回落）
-      stepUsages: Array.isArray(result.stepUsages) && result.stepUsages.length > 0
-        ? result.stepUsages
-        : undefined,
-      // 中性"仍在执行"标记（老 app 忽略未知字段；新读侧/排查可据此区分）
-      stillRunning: result.stillRunning === true ? true : undefined,
-      round: round?.rounds ?? 0,
-    });
-    round.totalTurns += 1;
-    return text;
-  }
-
   /**
    * 用户直接 @ 成员：被点名的成员直接回答，不经主管（用户定稿：直接 @ 生效）。
    * 不算「分发→反馈」轮次，也不触发任何接力。
@@ -776,22 +418,5 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast,
     }
   }
 
-  /**
-   * 打开群聊页时拉房间历史。
-   *
-   * 【读侧口径（2026-11-01）】
-   *   带 `stepUsages` 的新记录：用量由逐步数据**当场求和**再下发 —— 刷新/重进拿到的
-   *     值和实时那一刻完全同源（这份和也是 `usage` 字段的来源，二者恒等）。
-   *   没有 `stepUsages` 的旧记录：**原样返回**，显示当时写下的历史值。按负责人决定
-   *     历史不救 —— 这里不猜、不补 0、不拿别的字段假装重算。
-   */
-  function roomSnapshot(group) {
-    return (state.rooms[group.id] ?? []).slice(-ROOM_LOG_MAX).map((line) => {
-      if (!Array.isArray(line?.stepUsages) || line.stepUsages.length === 0) return line;
-      const usage = aggregateStepUsages(line.stepUsages);
-      return usage ? { ...line, usage } : line;
-    });
-  }
-
   return { handleUserMessage, roomSnapshot, ensureGroupSession };
 }