weaver-work-cli 0.1.28 → 0.1.29

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoSmartConvert.detail.js

@@ -0,0 +1,165 @@
+import { fetchRequestDetailsBatch } from './todoDetailFetcher.js';
+import { readBoundedInt } from './todoSmartConvert.core.js';
+import { openDetailCache } from './todoDetailCache.js';
+/**
+ * 把详情字段拼成喂模型的文本。
+ *
+ * 直接拼装详情取数阶段已经清洗过的字段值。
+ */
+export function contextOfDetail(detail) {
+    return detail.summaryFields.map((field) => `${field.fieldName}：${field.value}`).join('；');
+}
+const EMPTY_DETAIL_STATS = {
+    requested: 0,
+    fetched: 0,
+    cacheHit: 0,
+    contextAvailable: 0,
+    contextEmpty: 0,
+    failed: 0,
+    concurrency: 0,
+    durationMs: 0,
+};
+/** 缓存里存的、也是 `DetailFact` 用的字段裁剪口径：最多 8 个、每个值 80 字。 */
+export const DETAIL_MATERIAL_FIELD_LIMIT = 8;
+export const DETAIL_MATERIAL_VALUE_LIMIT = 80;
+/**
+ * 从条目集合里建 `requestId → lastFeedBackDateTime`。
+ *
+ * 为什么必须有它：详情缓存的键是 `requestId__lastFeedBackDateTime`，**不传 stamps 就永远是
+ * miss**（等于缓存白建）。这里统一从条目本身取时间戳，各阶段只要手上有 rows 就能建。
+ * 同一 requestId 出现多次（叠加视图）时取第一个非空值——它对同一条流程是同一个值。
+ */
+export function stampsOfRows(rows) {
+    const stamps = new Map();
+    for (const row of rows) {
+        const requestId = String(row?.requestId ?? '').trim();
+        if (!requestId || stamps.has(requestId))
+            continue;
+        const stamp = String(row?.lastFeedBackDateTime ?? '').trim();
+        if (stamp)
+            stamps.set(requestId, stamp);
+        else
+            stamps.set(requestId, '');
+    }
+    return stamps;
+}
+function materialFieldsOf(detail) {
+    return detail.summaryFields
+        .filter((field) => field.value.length <= 200)
+        .slice(0, DETAIL_MATERIAL_FIELD_LIMIT)
+        .map((field) => ({ fieldName: field.fieldName, value: field.value.slice(0, DETAIL_MATERIAL_VALUE_LIMIT) }));
+}
+/**
+ * 取流程详情数据：**缓存优先**（键 = `requestId__lastFeedBackDateTime`，7 天），
+ * 缓存没有再并发调 `/getWorkflowRequest`，取到后写回缓存（详情为空也写）。
+ *
+ * 失败不致命：返回已拿到的部分 + warning，调用方按「无详情」降级。
+ */
+export async function fetchDetailFacts(env, requestIds, args, stamps) {
+    const unique = [...new Set(requestIds.filter(Boolean))];
+    const facts = new Map();
+    const warnings = [];
+    const stats = { ...EMPTY_DETAIL_STATS, requested: unique.length };
+    if (unique.length === 0)
+        return { facts, stats, warnings };
+    const startedAt = Date.now();
+    const cache = await openDetailCache(env.ctx);
+    stats.cacheFile = cache.file;
+    // ① 缓存命中：不发请求
+    const missing = [];
+    for (const requestId of unique) {
+        const hit = cache.get(requestId, stamps?.get(requestId));
+        if (!hit) {
+            missing.push(requestId);
+            continue;
+        }
+        facts.set(requestId, {
+            context: hit.context,
+            contextAvailable: hit.contextAvailable,
+            metrics: hit.metrics,
+            fields: hit.fields,
+        });
+        stats.cacheHit += 1;
+    }
+    // ② 未命中：现场拉取并写缓存
+    if (missing.length > 0) {
+        let written = 0;
+        try {
+            const { details, stats: fetchStats } = await fetchRequestDetailsBatch(env, missing, {
+                concurrency: readBoundedInt(args.detailConcurrency, 'detailConcurrency', 10, 1, 32),
+                timeoutMs: readBoundedInt(args.detailTimeoutMs, 'detailTimeoutMs', 10_000, 1_000, 60_000),
+            });
+            stats.failed = fetchStats.failed;
+            stats.concurrency = fetchStats.concurrency;
+            for (const [requestId, detail] of details) {
+                const fact = {
+                    context: contextOfDetail(detail),
+                    contextAvailable: detail.summaryFields.length > 0,
+                    metrics: detail.metrics ?? {},
+                    fields: materialFieldsOf(detail),
+                };
+                facts.set(requestId, fact);
+                stats.fetched += 1;
+                if (fact.contextAvailable)
+                    stats.contextAvailable += 1;
+                else
+                    stats.contextEmpty += 1;
+                // 详情为空也写缓存：否则这类条目每次都要重拉
+                if (cache.set(requestId, stamps?.get(requestId), {
+                    context: fact.context,
+                    contextAvailable: fact.contextAvailable,
+                    metrics: fact.metrics,
+                    fields: fact.fields,
+                }))
+                    written += 1;
+            }
+        }
+        catch (error) {
+            warnings.push(`详情取数失败（${String(error?.message ?? error)}），本次按「无详情」降级处理`);
+        }
+        // 阶段末落盘一次（与摘要缓存一致），跨进程仍可复用
+        if (written > 0) {
+            const file = await cache.save();
+            if (file)
+                stats.cacheFile = file;
+        }
+    }
+    stats.durationMs = Date.now() - startedAt;
+    if (stats.failed > 0) {
+        warnings.push(`有 ${stats.failed} 条流程详情数据请求失败（已重试）；这些条目按「无详情」处理`);
+    }
+    return { facts, stats, warnings };
+}
+/**
+ * 详情上下文提供器：**同进程内存 → 详情缓存 → 现场拉取**，三级取数。
+ *
+ * `prefetched` 是同一进程里刚拉过的结果（`smartGroup + withDetailContext` 合并调用时复用）。
+ */
+export async function loadDetailContextProvider(env, requestIds, args, prefetched, stamps) {
+    const unique = [...new Set(requestIds.filter(Boolean))];
+    const fromMemory = unique.filter((id) => prefetched?.has(id));
+    const rest = unique.filter((id) => !prefetched?.has(id));
+    const reused = fromMemory.length;
+    const fetched = rest.length > 0
+        ? await fetchDetailFacts(env, rest, args, stamps)
+        : { facts: new Map(), stats: { ...EMPTY_DETAIL_STATS }, warnings: [] };
+    const all = new Map(prefetched ?? []);
+    for (const [requestId, fact] of fetched.facts)
+        all.set(requestId, fact);
+    const fallback = { context: '', contextAvailable: false };
+    return {
+        fetchedFromNetwork: fetched.stats.fetched,
+        reused,
+        stats: fetched.stats,
+        warnings: fetched.warnings,
+        get: (requestId) => {
+            const fact = all.get(requestId);
+            if (!fact)
+                return fallback;
+            return {
+                context: fact.context,
+                contextAvailable: fact.contextAvailable,
+            };
+        },
+    };
+}

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoSmartConvert.group.js

@@ -0,0 +1,448 @@
+import { workflowValidationError } from '../../errors.js';
+import { UNKNOWN_GROUP, groupKeyOf, readGroupBy, readItems, readTopN, assertKnownKeys, } from './todoSmartConvert.core.js';
+import { intentAppliesToKind, } from './businessRules.js';
+/** 紧急程度以 requestLevel=2 或显示文本「紧急」为准；1 级是「重要」。 */
+const URGENT_PATTERN = /紧急/u;
+export const PRIORITY_GROUP_ID = 'priority';
+export const PRIORITY_GROUP_TITLE = '建议优先处理的流程';
+/** 少于 3 条的工作流组不生成二次汇总项。 */
+export const GROUP_MIN_ITEMS_FOR_SUBGROUP = 3;
+/**
+ * 判断用户意图是否作用于这个业务类型（2026-10-26 换成 INTENT_RULES 表驱动）。
+ *
+ * 专属意图只作用于对应类型；通用意图只作用于内部留言与其他类；都不命中 ⇒ 视为没有意图。
+ * 实现见 `businessRules.ts` 的 `intentAppliesToKind`。
+ */
+export function focusAppliesToKind(focus, kind) {
+    return intentAppliesToKind(focus, kind);
+}
+/** 只用于接收时间区间比较；无法识别的时间不参与计算。 */
+export function timeOf(value) {
+    if (!value)
+        return undefined;
+    const text = value.trim();
+    if (/^\d{13}$/u.test(text))
+        return Number(text);
+    if (/^\d{10}$/u.test(text))
+        return Number(text) * 1000;
+    const parsed = Date.parse(text.replace(/\//gu, '-'));
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+/**
+ * 是否「紧急」。
+ *
+ * requestLevel 的码位为 0 正常、1 重要、2 紧急；文本只作兜底。
+ */
+export function isUrgentRow(row) {
+    if (row.requestLevel >= 2)
+        return true;
+    return URGENT_PATTERN.test(row.requestLevelShow);
+}
+/** `userOverTime` 是显示层文案（`昨天到期` / `05-07到期` / `11-30到期`），不一定代表「已超时」。 */
+const USER_OVER_TIME_PATTERN = /^(?:(\d{1,2})[-/](\d{1,2})\s*到期|昨天到期|已超时|今日到期)$/u;
+/** 判定「今年同月日」还是「去年同月日」：差超过半年，按去年算（跨年时 `12-20` 不该被当成年底未到）。 */
+const OVER_TIME_YEAR_WINDOW_MS = 180 * 24 * 60 * 60 * 1000;
+/**
+ * `userOverTime` 文本是否表示**已经**过期。
+ *
+ * 对只有月日的文案按当前年补齐；跨年时再回退到上一年。
+ * 认不出来的文案一律返回 `false` —— **不猜**，宁可漏一条也不把「未到期」误报成超时。
+ */
+export function isExpiredUserOverTime(text, now = Date.now()) {
+    const value = (text ?? '').trim();
+    if (!value)
+        return false;
+    if (/^(?:昨天到期|已超时)$/u.test(value))
+        return true;
+    const matched = USER_OVER_TIME_PATTERN.exec(value);
+    if (!matched || !matched[1])
+        return false;
+    const month = Number(matched[1]);
+    const day = Number(matched[2]);
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return false;
+    const base = new Date(now);
+    let stamp = new Date(base.getFullYear(), month - 1, day).getTime();
+    if (stamp - now > OVER_TIME_YEAR_WINDOW_MS) {
+        stamp = new Date(base.getFullYear() - 1, month - 1, day).getTime();
+    }
+    return stamp <= now;
+}
+/**
+ * 是否「超时」。
+ *
+ * 以接口算好的 `overTime`（displayData 的 `overdue`）为准；它缺失时用 `userOverTime` 文案兜底。
+ * 两个都用而不是只看文本：`11-30到期` 在 10-17 明显还没到期，按文本裸判会误收。
+ */
+export function isOverdueRow(row) {
+    if (row.overTime)
+        return true;
+    return isExpiredUserOverTime(row.userOverTime);
+}
+/**
+ * `userOverTime` 文本是否表示**今天到期**（还没过期）。
+ *
+ * 与 `isExpiredUserOverTime` 互补：`今日到期` 或 `MM-DD到期` 且该日期就是今天。
+ * 已经 `overTime=true` 的条目归「已过期」，这里返回 false，避免同一条被两边重复计入。
+ */
+function isExpiringTodayUserOverTime(text, now = Date.now()) {
+    const value = (text ?? '').trim();
+    if (!value)
+        return false;
+    if (/^今日到期$/u.test(value))
+        return true;
+    const matched = USER_OVER_TIME_PATTERN.exec(value);
+    if (!matched || !matched[1])
+        return false;
+    const month = Number(matched[1]);
+    const day = Number(matched[2]);
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return false;
+    const base = new Date(now);
+    let stamp = new Date(base.getFullYear(), month - 1, day).getTime();
+    if (stamp - now > OVER_TIME_YEAR_WINDOW_MS) {
+        stamp = new Date(base.getFullYear() - 1, month - 1, day).getTime();
+    }
+    const target = new Date(stamp);
+    return target.getFullYear() === base.getFullYear()
+        && target.getMonth() === base.getMonth()
+        && target.getDate() === base.getDate();
+}
+/** 是否**今天到期**（未过期；已过期用 `isOverdueRow`）。 */
+export function isExpiringTodayRow(row, now = Date.now()) {
+    if (row.overTime)
+        return false;
+    return isExpiringTodayUserOverTime(row.userOverTime, now);
+}
+/**
+ * 「建议优先处理的流程」筛选规则：
+ *
+ *  1. **超时** 必收（`userOverTime` / `overTime` 判定，与紧急程度无关）；
+ *  2. **紧急程度**按 `requestLevel` 取：整批有 `=2`（紧急）就只要 2；没有 2 才退到 `=1`（重要）；
+ *     `=0`（正常）**不因等级入选**——降级链到 1 就停，不倒到 0；
+ *  3. 整批连 1 级都没有（全 0）时，等级条件不生效，只按超时筛；此时若一条都没超时，
+ *     优先组为空（"实在没有紧急的就算了"），不硬凑。
+ *
+ * 注意这是**筛选**，不是视图叠加：入选条目的 `requestLevel` 只有 2（或 2 缺失时的 1）与超时两类。
+ */
+export function selectPriorityRows(rows) {
+    let maxLevel = 0;
+    for (const row of rows) {
+        if (row.requestLevel > maxLevel)
+            maxLevel = row.requestLevel;
+    }
+    const targetLevel = maxLevel >= 2 ? 2 : maxLevel >= 1 ? 1 : undefined;
+    const selected = [];
+    let overdueCount = 0;
+    let levelCount = 0;
+    let bothCount = 0;
+    for (const row of rows) {
+        const overdue = isOverdueRow(row);
+        const byLevel = targetLevel !== undefined && row.requestLevel >= targetLevel;
+        if (overdue)
+            overdueCount += 1;
+        if (byLevel)
+            levelCount += 1;
+        if (overdue && byLevel)
+            bothCount += 1;
+        if (overdue || byLevel)
+            selected.push(row);
+    }
+    return { rows: selected, targetLevel, overdueCount, levelCount, bothCount };
+}
+/**
+ * 优先组内部排序：先「既超时又高级」的，再「仅超时」，最后「仅等级」；
+ * 同档按接收时间升序（越早收到越该先处理），时间取不到排后。
+ */
+export function sortPriorityRows(rows) {
+    const rankOf = (row) => {
+        const overdue = isOverdueRow(row);
+        if (overdue && row.requestLevel >= 2)
+            return 0;
+        if (overdue)
+            return 1;
+        return 2;
+    };
+    return [...rows].sort((a, b) => {
+        const rank = rankOf(a) - rankOf(b);
+        if (rank !== 0)
+            return rank;
+        const at = timeOf(a.receivedTime) ?? Number.MAX_SAFE_INTEGER;
+        const bt = timeOf(b.receivedTime) ?? Number.MAX_SAFE_INTEGER;
+        if (at !== bt)
+            return at - bt;
+        return a.requestId.localeCompare(b.requestId);
+    });
+}
+/** 分组维度用的紧急程度文本：优先显示层文本，没有文本时按码位给出「紧急」，仍取不到就归未分类。 */
+function urgencyOf(row) {
+    if (row.requestLevelShow)
+        return row.requestLevelShow;
+    return row.requestLevel >= 2 ? '紧急' : UNKNOWN_GROUP;
+}
+/** 内部行 → 目标 requestData：**只挑目标字段**，内部辅助位（workflowName/receivedTime/amount…）不外泄。 */
+export function toRequestData(row) {
+    return {
+        requestId: row.requestId,
+        workflowId: row.workflowId,
+        userMasterId: row.userMasterId,
+        isremark: row.isremark,
+        nodeId: row.nodeId,
+        overTime: row.overTime,
+        userOverTime: row.userOverTime,
+        requestLevel: row.requestLevel,
+        requestLevelShow: row.requestLevelShow,
+        requestNameTitle: row.requestNameTitle,
+        creater: row.creater,
+        createrName: row.createrName,
+        lastFeedBackDateTime: row.lastFeedBackDateTime,
+        summary: row.summary ?? '',
+    };
+}
+export function statsOf(rows) {
+    let overdueCount = 0;
+    let urgentCount = 0;
+    let earliest = null;
+    let latest = null;
+    for (const row of rows) {
+        if (isOverdueRow(row))
+            overdueCount += 1;
+        if (isUrgentRow(row))
+            urgentCount += 1;
+        const stamp = timeOf(row.receivedTime);
+        if (stamp !== undefined && row.receivedTime) {
+            if (!earliest || stamp < earliest.time)
+                earliest = { text: row.receivedTime, time: stamp };
+            if (!latest || stamp > latest.time)
+                latest = { text: row.receivedTime, time: stamp };
+        }
+    }
+    return {
+        overdueCount,
+        urgentCount,
+        receivedRange: earliest && latest ? { earliest: earliest.text, latest: latest.text } : null,
+    };
+}
+function markdownCell(value) {
+    return value.replace(/\|/gu, '\\|');
+}
+export function renderGroupMarkdown(params) {
+    const { groupBy, total, groups, restGroupCount, restCount } = params;
+    const dimension = {
+        workflow: '按工作流名称',
+        urgency: '按紧急程度',
+        date: '按接收日期',
+        none: '不分组',
+    };
+    const lines = [
+        `待办分组（${dimension[groupBy]}，共 ${total} 条，${groups.length + restGroupCount} 组）`,
+        '',
+        '| 分组 | 条数 | 超时 | 紧急 |',
+        '| --- | --- | --- | --- |',
+    ];
+    for (const group of groups) {
+        lines.push(`| ${markdownCell(group.title)} | ${group.count} | ${group.stats.overdueCount} | ${group.stats.urgentCount} |`);
+    }
+    if (restGroupCount > 0) {
+        lines.push(`| 其余 ${restGroupCount} 组 | ${restCount} | — | — |`);
+    }
+    return lines.join('\n');
+}
+/**
+ * 读取用户意图顺序（`groupOrder`）：模型按提示词里「先看请假、满意度放最后」这类意图
+ * 给出的分组顺序，元素可以是 `workflowName` 也可以是分组 id。
+ *
+ * 为什么不自己做「意图识别」：排序意图只能用自然语言表达，CLI 猜不准；
+ * 而模型已经读过提示词，让它**显式把顺序写出来**、CLI 只做重排与校验，
+ * 才不会出现「同一句话两次跑出两种顺序」。
+ */
+export function readGroupOrder(args) {
+    const raw = args.groupOrder;
+    if (raw === undefined || raw === null)
+        return [];
+    if (!Array.isArray(raw)) {
+        throw workflowValidationError('group_order_invalid', 'groupOrder 必须是字符串数组：按**期望展示顺序**列出 workflowName 或分组 id（没列到的组按源数据顺序排在后面）', { retryAllowed: true });
+    }
+    const order = [];
+    for (const item of raw) {
+        const text = String(item ?? '').trim();
+        if (text && !order.includes(text))
+            order.push(text);
+    }
+    return order;
+}
+/**
+ * 按 `groupOrder` 重排分组：**优先组永远第一**（它是筛选出来的置顶视图，不属于工作流清单），
+ * 其余按给定顺序在前、未提到的保持源数据顺序在后。
+ *
+ * 匹配不上的名字不报错、只回传 `unknown`（模型可能用了「请假类」这种口径名而不是流程名）；
+ * 全都不匹配时结果与不传等价 —— 顺序意图给错了，最多「没生效」，不该让整次汇总失败。
+ */
+export function orderGroupsByIntent(groups, order) {
+    if (order.length === 0)
+        return { groups, applied: 0, unknown: [] };
+    const pinned = groups.filter((group) => group.topPriority === true);
+    const rest = groups.filter((group) => group.topPriority !== true);
+    const chosen = [];
+    const unknown = [];
+    for (const key of order) {
+        const hit = rest.find((group) => !chosen.includes(group) && (group.id === key || group.title === key));
+        if (hit)
+            chosen.push(hit);
+        else
+            unknown.push(key);
+    }
+    return {
+        groups: [...pinned, ...chosen, ...rest.filter((group) => !chosen.includes(group))],
+        applied: chosen.length,
+        unknown,
+    };
+}
+/**
+ * 分组阶段：`items` → 目标的 `wfIdGroup`。
+ *
+ * 口径（都是确定值，不要交给模型算）：
+ *  - **计数唯一规则**：任何分组的 `count` 都等于该组内 displayData 的行数，
+ *    有几条数据就计几；没有第二套口径（不按发起人、不按流程、不按金额派生计数）。
+ *    跨页重叠的同一 `requestId` 视为同一行、只计一次（此时 `duplicateCount` 会说明原始条数），
+ *    因为那是同一行数据被取了两遍，不是两条待办。
+ *  - 分组键默认 `workflowName`（`groupBy=workflow`；`workflowId : workflowName` 是多对一，
+ *    多版本必须合并成一组）；`id` 用 workflowId，缺 id 时用 `name:<名称>`；
+ *  - **优先组**：按 `selectPriorityRows` 筛出的条目单独成一组 `id=priority`，固定第一；
+ *    它是**叠加视图**而不是筛选——入选条目**仍保留在各自的工作流分组里**（优先组只是
+ *    置顶入口，方便先看要紧的几条）。因此 `Σcount` 会大于 `totalCount`，
+ *    **`totalCount` 一律按去重后的条数计算，不做分组求和**；
+ *  - 排序：优先组固定第一；其余**跟随源数据**——`getTodoListData` 返回里 `workflowName`
+ *    的首次出现顺序，不按条数、不按名称重排；
+ *    用户提示词里有明确顺序意图时，由模型把期望顺序写进 `groupOrder`，CLI 只按它重排；
+ *  - `topN` **只裁剪 markdown**，`wfIdGroup` 永远全量——下一步要按组遍历，不能因展示折叠丢数据。
+ */
+export function runGroup(args) {
+    assertKnownKeys(args);
+    const { rawCount, rows, duplicateCount, unreadableCount } = readItems(args.items);
+    const groupBy = readGroupBy(args.groupBy);
+    const topN = readTopN(args.topN);
+    // 优先组是叠加视图：筛出的条目**不从**工作流分组剔除，两个视图各自完整。
+    const priority = selectPriorityRows(rows);
+    const priorityRows = sortPriorityRows(priority.rows);
+    const restRows = rows;
+    const buckets = new Map();
+    for (const row of restRows) {
+        const key = groupKeyOf(row, groupBy);
+        let bucket = buckets.get(key);
+        if (!bucket) {
+            // 目标用 workflowId 当分组 id；其它维度没有业务 id，直接用键值。
+            const id = groupBy === 'workflow' ? (row.workflowId || `name:${key}`) : key;
+            bucket = { id, title: key, rows: [], ids: [] };
+            buckets.set(key, bucket);
+        }
+        if (groupBy === 'workflow' && row.workflowId && !bucket.ids.includes(row.workflowId)) {
+            bucket.ids.push(row.workflowId);
+        }
+        bucket.rows.push(row);
+    }
+    // 顺序跟随源数据——`getTodoListData` 返回里 `workflowName`
+    // 首次出现的顺序，即 `buckets` 的插入顺序。不做条数降序、不做名称排序：
+    // 清单顺序应当和人在待办列表里看到的顺序一致，重排会让「同一批数据两次跑出不同位置」。
+    // 有明确顺序意图时由 `groupOrder` 显式给出，这里只做重排。
+    const ordered = orderGroupsByIntent([...buckets.values()], readGroupOrder(args));
+    const workflowGroups = ordered.groups.map((bucket) => ({
+        id: bucket.id,
+        topPriority: false,
+        title: bucket.title,
+        count: bucket.rows.length,
+        requestDatas: bucket.rows.map((row) => toRequestData(row)),
+        stats: statsOf(bucket.rows),
+        ...(bucket.ids.length > 1 ? { workflowIds: bucket.ids } : {}),
+    }));
+    const groups = priorityRows.length > 0 && groupBy === 'workflow'
+        ? [{
+                id: PRIORITY_GROUP_ID,
+                topPriority: true,
+                title: PRIORITY_GROUP_TITLE,
+                count: priorityRows.length,
+                requestDatas: priorityRows.map((row) => toRequestData(row)),
+                stats: statsOf(priorityRows),
+            }, ...workflowGroups]
+        : workflowGroups;
+    const displayedWorkflow = workflowGroups.slice(0, topN);
+    const displayed = priorityRows.length > 0 && groupBy === 'workflow'
+        ? [groups[0], ...displayedWorkflow]
+        : displayedWorkflow;
+    const rest = workflowGroups.slice(topN);
+    const restCount = rest.reduce((sum, group) => sum + group.count, 0);
+    const overall = statsOf(rows);
+    const warnings = [];
+    if (duplicateCount > 0) {
+        warnings.push(`已按 requestId 去重：原始 ${rawCount} 条，唯一 ${rows.length} 条，重复 ${duplicateCount} 条`);
+    }
+    if (unreadableCount > 0) {
+        warnings.push(`有 ${unreadableCount} 条不是对象结构，已跳过`);
+    }
+    const unknownGroupCount = buckets.get(UNKNOWN_GROUP)?.rows.length ?? 0;
+    if (unknownGroupCount > 0) {
+        warnings.push(groupBy === 'workflow'
+            ? `有 ${unknownGroupCount} 条缺少工作流名称，已归入「${UNKNOWN_GROUP}」`
+            : `有 ${unknownGroupCount} 条缺少分组字段，已归入「${UNKNOWN_GROUP}」`);
+    }
+    if (priorityRows.length > 0 && groupBy === 'workflow') {
+        const levelText = priority.targetLevel === 2
+            ? '紧急（requestLevel=2）'
+            : priority.targetLevel === 1
+                ? '重要（requestLevel=1；本次无 2 级数据，已按规则降级取 1，0 级不取）'
+                : '无等级（本次整批没有 ≥1 级的条目，只按超时筛）';
+        warnings.push(`「${PRIORITY_GROUP_TITLE}」筛出 ${priorityRows.length} 条：超时 ${priority.overdueCount} 条 / ` +
+            `等级命中 ${priority.levelCount} 条（两者都满足 ${priority.bothCount} 条），等级口径=${levelText}；` +
+            `这 ${priorityRows.length} 条同时保留在各自工作流分组中（叠加视图：Σcount 会大于 totalCount，` +
+            `totalCount 按去重条数计 = ${rows.length}）`);
+    }
+    else if (priorityRows.length === 0 && groupBy === 'workflow') {
+        warnings.push(`本次没有超时条目，也没有 requestLevel≥1 的条目，故不输出「${PRIORITY_GROUP_TITLE}」分组`);
+    }
+    if (rest.length > 0) {
+        warnings.push(`markdown 只展示前 ${topN} 个工作流分组，其余 ${rest.length} 组共 ${restCount} 条仍在 wfIdGroup 中（未截断）`);
+    }
+    if (ordered.applied > 0) {
+        warnings.push(`已按 groupOrder 重排分组顺序（命中 ${ordered.applied} 组）；未提到的组按接口返回的 workflowName 顺序排在后面`);
+    }
+    if (ordered.unknown.length > 0) {
+        warnings.push(`groupOrder 里有 ${ordered.unknown.length} 项没有匹配到任何分组（${ordered.unknown.join('、')}）：`
+            + '请用 workflowName 或分组 id；这些项已忽略，其余顺序照常');
+    }
+    // workflowId : workflowName 是**多对一**（工作流有多版本），所以同名必须合并、不能按 id 拆开。
+    const multiVersionGroups = workflowGroups.filter((group) => (group.workflowIds?.length ?? 0) > 1);
+    if (multiVersionGroups.length > 0) {
+        const detail = multiVersionGroups
+            .map((group) => `${group.title}（${group.workflowIds.length} 个版本）`)
+            .join('、');
+        warnings.push(`检测到同一工作流名称对应多个 workflowId：${detail}；已按 workflowName 合并为一组，` +
+            `id 取第一个版本，完整版本列表见该组 workflowIds`);
+    }
+    return {
+        stage: 'group',
+        groupBy,
+        smartSummaryTitle: `您当前有 ${rows.length} 条待办，清单如下：`,
+        totalInput: rawCount,
+        total: rows.length,
+        duplicateCount,
+        groupCount: groups.length,
+        totals: {
+            totalCount: rows.length,
+            overdueCount: overall.overdueCount,
+            urgentCount: overall.urgentCount,
+        },
+        wfIdGroup: groups,
+        /** 第二部分（非优先组）的总条数与组数，前端折叠/分页直接用它，不用自己减 */
+        restTotal: restRows.length,
+        restGroupCount: workflowGroups.length,
+        restGroups: rest.length > 0 ? { groupCount: rest.length, count: restCount } : null,
+        warnings,
+        markdown: renderGroupMarkdown({
+            groupBy,
+            total: rows.length,
+            groups: displayed,
+            restGroupCount: rest.length,
+            restCount,
+        }),
+    };
+}