jbc-dssi 1.1.5 → 1.1.7

package/package.json

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

package/vendor/groups/bridge/engine.js

@@ -25,8 +25,36 @@ import { buildManagerPrompt, buildMemberPrompt } from './prompt.js';
 
 /** 房间日志最多保留条数（超出丢最旧，防无限膨胀）。 */
 const ROOM_LOG_MAX = 60;
-/** 单个成员一轮回复的等待上限。 */
-const TURN_TIMEOUT_MS = 240_000;
+
+/**
+ * 群任务等待窗口（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/;
+
+/**
+ * 按任务文案挑等待预算：长任务 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 轮收齐反馈后必须强制汇报，
@@ -126,12 +154,24 @@ function aggregateStepUsages(stepUsages) {
  * @param {Function} opts.save 持久化（串行写）
  * @param {Function} opts.broadcast 群事件广播
  */
-export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }) {
+export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast, timings = {} }) {
   /** 当前活跃任务（同一时刻只跑一个群的一轮，防止消息乱序）。 */
   let activeRound = null;
 
   const now = () => Date.now();
 
+  /** 等待窗口参数：生产用默认值；测试注入小值（不新增配置项，也不改协议）。 */
+  const timing = {
+    idleMs: TURN_IDLE_TIMEOUT_MS,
+    defaultBudgetMs: TURN_BUDGET_DEFAULT_MS,
+    longBudgetMs: TURN_BUDGET_LONG_MS,
+    lateMaxMs: LATE_WATCH_MAX_MS,
+    ...timings,
+  };
+  /** 按任务文案选预算（发版/构建类 → 长窗口）。 */
+  const budgetFor = (taskText) =>
+    taskBudgetMs(taskText, { defaultMs: timing.defaultBudgetMs, longMs: timing.longBudgetMs });
+
   /**
    * 追加一行到房间日志。
    *
@@ -177,16 +217,23 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
   /**
    * 投递一轮给一个成员，等回复完成后 settle。
    *
-   * @returns {Promise<{text?:string, failed?:string, missed?:boolean,
+   * @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 = {}) {
+  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 timeoutTimer = null;
+      let idleTimer = null;
+      let budgetTimer = null;
+      let lateTimer = null;
       /*
        * ★ 结算判据：等「整个 turn 结束」，不是「第一条 assistant/message」。
        *
@@ -231,12 +278,27 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       const turnStepNums = new Map();
       let lastTurn = -1;
 
+      const clearIdle = () => {
+        if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; }
+      };
       const settle = (result) => {
         if (settled) return;
         settled = true;
-        if (timeoutTimer) clearTimeout(timeoutTimer);
+        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 {
@@ -263,7 +325,9 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
                *   于是上一位的尾巴被画进了下一位的块里，表现为
                *   「上一成员没有输出，下一成员的话就来了」（用户实测原话）。
                */
-              if (followClosed || settled) break;
+              // 成功/明确失败才停；预算耗尽后进入"补发观察"，继续安静跟随却不再广播
+              if (followClosed || (settled && !lateWait)) break;
+              noteActivity();
               // 群消息流式增量：与智能体单聊同一推送机制 —— assistant-stream 帧原样
               // 广播给手机（room_stream），手机侧用单聊同款 reduceLive 边收边画；
               // 完整文本仍由 assistant/message → settle → room_line 落盘（下方处理）。
@@ -312,17 +376,27 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
                   }
                 } 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') {
-                    settle({ failed: String(data.reason?.message ?? kind) });
-                  } else {
+                    const failed = String(data.reason?.message ?? kind);
+                    if (settled && lateWait) emitLateFailure(group, member, failed, roundNo);
+                    else settle({ failed });
+                  } else if (settled && lateWait) {
                     /*
-                     * 本轮步数：取 turn/end 指向的那一轮（拿不到就退回最后见过的一轮）。
-                     * 0 = 没统计到（老版本插件 / 事件里没带 step）→ 手机侧整段不显示。
+                     * 预算耗尽后迟到的真实结果 → 作为**同一轮的补发行**落库（回填，不丢弃）。
+                     * 这是"不用 240 秒误判长任务"的最后一环。
                      */
-                    const endTurn = typeof data.turn === 'number' ? data.turn : lastTurn;
-                    const steps = turnStepNums.get(endTurn)?.size ?? 0;
+                    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 ?? '会话失败') });
@@ -365,9 +439,23 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
             );
             // 请求已进队列：此后到达的事件才属于本轮（之前的都是历史回放）。
             prompted = true;
-            timeoutTimer = setTimeout(() => {
-              if (!settled) settle({ missed: true });
-            }, TURN_TIMEOUT_MS);
+            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;
@@ -395,8 +483,41 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
    * 新手机的 GroupStore 优先用 `stepUsages` 求和 —— 刷新/重进后与实时同源。
    * 旧行没有 `stepUsages`：读侧原样显示历史值，不补 0、不重算、不报错（历史不救）。
    */
-  function emitReplyLine(group, round, member, result) {
+  /** 预算耗尽后迟到的真实回复：作为**同一轮的补发行**追加（不改已有行、不丢结果）。 */
+  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',
@@ -409,6 +530,8 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       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;
@@ -429,7 +552,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
         task: text,
         mode: 'user-direct',
       });
-      const result = await deliver(group, member, prompt, attachments);
+      const result = await deliver(group, member, prompt, attachments, { budgetMs: budgetFor(text), round });
       if (result.failed) {
         emitLine(group.id, {
           at: now(), role: 'system', name: member.name,
@@ -468,7 +591,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
       });
       // 用户附件只在第一轮（计划阶段）带给主管；后续复查阶段不再重复投递。
       const managerAttachments = roundIndex === 0 && feedbacks.length === 0 ? attachments : {};
-      const result = await deliver(group, manager, prompt, managerAttachments);
+      const result = await deliver(group, manager, prompt, managerAttachments, { round });
       if (result.failed) {
         emitLine(group.id, {
           at: now(), role: 'system', name: manager.name,
@@ -542,7 +665,10 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
           task: managerText,
           mode: 'manager-task',
         });
-        const memberResult = await deliver(group, target, memberPrompt, attachments);
+        const memberResult = await deliver(group, target, memberPrompt, attachments, {
+          budgetMs: budgetFor(managerText),
+          round,
+        });
         if (memberResult.failed) {
           emitLine(group.id, {
             at: now(), role: 'system', name: target.name,
@@ -554,7 +680,7 @@ export function createRoundEngine({ ctx, state, dssAgent, log, save, broadcast }
           continue;
         }
         const text = emitReplyLine(group, round, target, memberResult);
-        feedbacks.push({ name: target.name, text, missed: memberResult.missed === true });
+        feedbacks.push({ name: target.name, text, stillRunning: memberResult.stillRunning === true });
       }
       // 第 MAX_ROUNDS 轮反馈收齐 → 下一句主管只能汇报
       forcedReport = roundIndex >= MAX_ROUNDS;

package/vendor/groups/bridge/prompt.js

@@ -64,7 +64,7 @@ export function buildManagerPrompt({
   const feedbackText = (feedbacks ?? []).length
     ? (feedbacks ?? [])
       .map((f) => {
-        const tag = f.failed ? '（回应失败）' : f.missed ? '（未回应）' : '';
+        const tag = f.failed ? '（回应失败）' : f.stillRunning ? '（仍在执行）' : '';
         const text = String(f.text ?? '').replace(/\s+/g, ' ').slice(0, LINE_TEXT_MAX);
         return `- ${f.name}${tag}：${text}`;
       })