weaver-work-cli 0.1.28 → 0.1.29

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

@@ -0,0 +1,502 @@
+import { workflowValidationError } from '../../errors.js';
+import { BUSINESS_KIND_LABEL, detectBusinessKind, FINANCE_AMOUNT_THRESHOLD, FINANCE_GROUP_TITLE, formatFinanceGroupSummary, formatIssueSupportGroupSummary, formatLeaveGroupSummary, isDeterministicGroupKind, ISSUE_SUPPORT_GROUP_TITLE, LEAVE_DAY_THRESHOLD, LEAVE_GROUP_TITLE, normalizeCreators, } from './businessRules.js';
+import { asRecord, readBoundedInt, } from './todoSmartConvert.core.js';
+import { focusAppliesToKind, isExpiringTodayRow, isExpiredUserOverTime, PRIORITY_GROUP_ID, PRIORITY_GROUP_TITLE, runGroup, GROUP_MIN_ITEMS_FOR_SUBGROUP, } from './todoSmartConvert.group.js';
+import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
+import { openSummaryCache } from './summaryCache.js';
+const DEFAULT_REQUEST_SUMMARY_MAX = 50;
+/** 把一批条目包成「单独展示」项（优先组、以及普通组里没同类可合并的条目都用它）。 */
+export function requestItemsOf(rows) {
+    return rows.map((row) => ({ type: 'request', requestData: row }));
+}
+/** 一个分组下的所有条目（按 `displayItems` 顺序摊平）。 */
+export function rowsOfGroup(group) {
+    return group.displayItems.flatMap((item) => (item.type === 'group' ? item.requestDatas : [item.requestData]));
+}
+/** 一个分组下的汇总项（`type:"group"`）。 */
+export function groupItemsOf(group) {
+    return group.displayItems.filter((item) => item.type === 'group');
+}
+/**
+ * 校验并索引 `aiGroups`。
+ *
+ * 入参形态（扁平数组，比「按组嵌套的对象」更省 token、也更好报错定位）：
+ * ```json
+ * [ { "groupId": "1003655203465764898", "title": "<AI 起的组名>", "requestIds": ["1326409832331878420"] } ]
+ * ```
+ * `groupId` 就是 `stage=group` 输出里 `wfIdGroup[i].id`。
+ * **id 一律按字符串处理**：真实 workflowId / requestId 是 19 位，用数字存会末位失真。
+ */
+export function readAiGroups(value) {
+    if (!Array.isArray(value)) {
+        throw workflowValidationError('ai_groups_invalid', "aiGroups 必须是数组，每项形如 { groupId, title, requestIds }；groupId 取 stage=group 输出里的 wfIdGroup[i].id", { retryAllowed: false });
+    }
+    const map = new Map();
+    value.forEach((raw, index) => {
+        const label = `aiGroups[${index}]`;
+        const record = asRecord(raw);
+        if (!record) {
+            throw workflowValidationError('ai_groups_invalid', `${label} 必须是对象 { groupId, title, requestIds }`, { retryAllowed: false });
+        }
+        const unknownKeys = Object.keys(record).filter((key) => !['groupId', 'title', 'requestIds', 'seq'].includes(key));
+        if (unknownKeys.length > 0) {
+            throw workflowValidationError('ai_groups_invalid', `${label} 不接受字段：${unknownKeys.join(', ')}；只支持 groupId / title / requestIds / seq`, { retryAllowed: false, details: { unknownKeys } });
+        }
+        const groupId = typeof record.groupId === 'string' ? record.groupId.trim() : '';
+        if (!groupId) {
+            throw workflowValidationError('ai_groups_invalid', `${label}.groupId 必填且必须是字符串（19 位 workflowId 用数字会失真；值取 stage=group 的 wfIdGroup[i].id）`, { retryAllowed: false });
+        }
+        const title = typeof record.title === 'string' ? record.title.trim() : '';
+        if (!title) {
+            throw workflowValidationError('ai_groups_invalid', `${label}.title 必填：这是 AI 给该子分组起的名字，结构里要原样输出`, { retryAllowed: false });
+        }
+        const hasIds = Array.isArray(record.requestIds) && record.requestIds.length > 0;
+        const hasSeq = Array.isArray(record.seq) && record.seq.length > 0;
+        if (hasIds && hasSeq) {
+            throw workflowValidationError('ai_groups_invalid', `${label} 不能同时给 requestIds 与 seq：用 seq（组内序号，推荐）或 requestIds（显式 ID）二选一`, { retryAllowed: false });
+        }
+        if (!hasIds && !hasSeq) {
+            throw workflowValidationError('ai_groups_invalid', `${label} 需要 requestIds 或 seq（组内 1-based 序号，见 collect 的 groupingBrief）`, { retryAllowed: false });
+        }
+        const seqNumbers = [];
+        if (hasSeq) {
+            for (const item of record.seq) {
+                const n = typeof item === 'number' ? item : Number(item);
+                if (!Number.isInteger(n) || n < 1) {
+                    throw workflowValidationError('ai_groups_invalid', `${label}.seq 只接受 ≥1 的整数序号，收到 ${String(item)}`, { retryAllowed: false });
+                }
+                seqNumbers.push(n);
+            }
+        }
+        const ids = [];
+        for (const item of (hasIds ? record.requestIds : [])) {
+            const id = typeof item === 'string' ? item.trim() : typeof item === 'number' ? String(item) : '';
+            if (!id) {
+                throw workflowValidationError('ai_groups_invalid', `${label}.requestIds 只接受非空的 requestId 字符串`, { retryAllowed: false });
+            }
+            ids.push(id);
+        }
+        const bucket = map.get(groupId) ?? [];
+        bucket.push({ groupId, title, requestIds: [...new Set(ids)], seq: [...new Set(seqNumbers)] });
+        map.set(groupId, bucket);
+    });
+    return map;
+}
+/** 从详情事实里抽 metrics（确定性分组用）。 */
+export function metricsOfFacts(facts) {
+    const metrics = new Map();
+    for (const [requestId, fact] of facts)
+        metrics.set(requestId, fact.metrics);
+    return metrics;
+}
+/** 从详情事实里造「空详情」判断器。 */
+export function ctxEmptyOf(facts) {
+    return (requestId) => {
+        const fact = facts.get(requestId);
+        return fact !== undefined && !fact.contextAvailable;
+    };
+}
+/**
+ * 一条待办的业务指标：**只来自流程详情数据**（Q3：去掉标题兜底）。
+ * 取不到就是空对象，调用方据此把该条平铺、不做 ai二次分组。
+ */
+function rowMetricsOf(row, metrics) {
+    return metrics?.get(row.requestId) ?? {};
+}
+/**
+ * 确定性路径的二次分组汇总项使用固定组摘要；请假/财务保留各自专用模板，其他类型使用标题/发起人模板。
+ *
+ * 金额算不出来时（表单没有金额字段、标题里也没有 `X元`）退回「标题清单」模板，
+ * 而不是编一个 `¥0 ~ ¥0` —— 半截统计比不给更糟。
+ */
+function deterministicGroupSummary(kind, rows, metrics, restCount = 0) {
+    if (!isDeterministicGroupKind(kind))
+        return null;
+    const creators = normalizeCreators(rows.map((row) => row.createrName));
+    // 客户问题支持类：固定「N 条已过期或今日到期 + 其余 M 条单条」口径，条数由 CLI 算。
+    if (kind === 'issue-support') {
+        return formatIssueSupportGroupSummary({ count: rows.length, restCount, creators });
+    }
+    if (kind === 'leave') {
+        const items = rows.map((row) => rowMetricsOf(row, metrics));
+        return formatLeaveGroupSummary({
+            count: rows.length,
+            leaveTypes: items.map((item) => item.leaveType),
+            creators,
+        });
+    }
+    if (kind === 'finance') {
+        const items = rows.map((row) => rowMetricsOf(row, metrics));
+        const amounts = items
+            .map((item) => item.amount)
+            .filter((value) => typeof value === 'number' && value > 0);
+        // 防御：能进阈值组的前提就是「金额 ≤100」，所以这里必然有金额；
+        // 万一真的一个都没有，留空交 AI 写，绝不编一个 ¥0 ~ ¥0。
+        if (amounts.length === 0)
+            return null;
+        const sum = Number(amounts.reduce((total, value) => total + value, 0).toFixed(2));
+        return formatFinanceGroupSummary({
+            min: Math.min(...amounts),
+            max: Math.max(...amounts),
+            sum,
+            categories: items.map((item) => item.feeCategory),
+            creators,
+        });
+    }
+    // 其他类不再产汇总项（isDeterministicGroupKind 已排除），走到这里直接返回 null。
+    return null;
+}
+/**
+ * 最终结构里的 `totalCount`：**去重后的待办条数**（= collect 阶段取到的全部条数）。
+ *
+ * 为什么**不能**用 Σ `wfIdGroup[].count`：优先组是叠加视图，同一条待办会同时出现在
+ * 「建议优先处理的流程」和它的工作流分组里，按组求和会把这类条目算两遍。
+ * 这里按 `requestId` 去重后计数，与 collect 的 `fetched` 同源同值。
+ *
+ * 兜底：万一结构里没有 `displayItems`（理论上不会，`readFinalGroups` 已归一），
+ * 才退回按 `count` 求和，避免返回 0。
+ */
+export function totalTodoCount(groups) {
+    const seen = new Set();
+    let sawRow = false;
+    for (const group of groups) {
+        for (const item of group.displayItems ?? []) {
+            const rows = item.type === 'group' ? (item.requestDatas ?? []) : [item.requestData];
+            for (const row of rows) {
+                sawRow = true;
+                seen.add(rowKeyForCount(row));
+            }
+        }
+    }
+    if (!sawRow)
+        return groups.reduce((sum, group) => sum + (Number(group.count) || 0), 0);
+    return seen.size;
+}
+/** 计数的去重键：优先 `requestId`；缺 id 时用「标题 + 发起人 + 节点」兜底。 */
+function rowKeyForCount(row) {
+    if (!row)
+        return 'missing';
+    const id = String(row.requestId ?? '').trim();
+    if (id)
+        return `id:${id}`;
+    return `tx:${row.requestNameTitle ?? ''}|${row.creater ?? ''}|${row.nodeId ?? ''}`;
+}
+export async function runSmartGroup(args, env, options = {}) {
+    const base = runGroup(args);
+    const groups = (base.wfIdGroup ?? []);
+    /** `null` = 确定性模式；数组（可能为空）= 兼容模式 */
+    const plans = args.aiGroups === undefined || args.aiGroups === null
+        ? undefined
+        : readAiGroups(args.aiGroups);
+    // 注意：`aiGroups: []` 与「未传」现在等价（默认不分组），不再需要用空数组区分语义。
+    // 有侧重点时分组 = 标题语义 + 侧重点；子组顺序沿用模型返回顺序。
+    // 无侧重点时普通组按条数降序，请假/财务使用阈值规则。
+    const groupFocus = typeof args.groupFocus === 'string' ? args.groupFocus.trim() : '';
+    const hasFocus = groupFocus.length > 0;
+    // 摘要字数口径：缓存命中要按口径过滤（10 字要求不能吃 50 字的旧摘要）。
+    const summaryMaxChars = readBoundedInt(args.summaryMaxChars, "summaryMaxChars", DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+    // 详情用来算阈值指标 + 判定空上下文；摘要缓存只省 AI，不省详情（阈值指标只认流程详情数据）。
+    // withDetailContext=false 时只生成结构、不获取详情（此时没有指标，阈值规则自然不生效）。
+    const skipDetail = args.withDetailContext === false;
+    const summaryCache = await openSummaryCache(env.ctx);
+    const cachedIds = new Set();
+    const allRows = [];
+    for (const group of groups) {
+        for (const row of group.requestDatas ?? []) {
+            allRows.push(row);
+            if (summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars))
+                cachedIds.add(row.requestId);
+        }
+    }
+    // 详情缓存已经按 `requestId__lastFeedBackDateTime` 落盘，命中时零请求；
+    // 所以「摘要命中」不再等于「可以不拉详情」——否则阈值分组会因为没有指标而失效（回归 10.2）。
+    const detailIds = [...new Set(allRows.map((row) => row.requestId).filter(Boolean))];
+    // stamps 决定详情缓存的键：不传就永远 miss（缓存白建）。
+    const stamps = stampsOfRows(allRows);
+    const facts = skipDetail
+        ? new Map()
+        : (options.facts ?? (await fetchDetailFacts(env, detailIds, args, stamps)).facts);
+    const metrics = skipDetail ? undefined : (options.metrics ?? metricsOfFacts(facts));
+    const knownGroupIds = new Set(groups.map((group) => group.id));
+    for (const groupId of plans?.keys() ?? []) {
+        if (!knownGroupIds.has(groupId)) {
+            throw workflowValidationError('ai_group_unknown_group', `aiGroups 里的 groupId「${groupId}」不在本次分组结果中；可用的 groupId：${[...knownGroupIds].join(', ')}`, { retryAllowed: true, details: { availableGroupIds: [...knownGroupIds] } });
+        }
+        if (groupId === PRIORITY_GROUP_ID) {
+            throw workflowValidationError('ai_group_priority_unsupported', `「${PRIORITY_GROUP_TITLE}」不做二次分组：目标结构里它只有 displayItems（全是单条展示），没有汇总项；请把它的条目从 aiGroups 里去掉`, { retryAllowed: true });
+        }
+    }
+    // markdown 是中间态的东西，最终结构里没有，相关提示一并丢掉，免得误导调用方。
+    const warnings = (base.warnings ?? [])
+        .filter((text) => !text.startsWith('markdown 只展示前'));
+    if (skipDetail) {
+        warnings.push('withDetailContext=false：本次未拉取任何详情——请假/财务阈值改为按标题识别、跳过整组空判定，也不产 summaryBatches');
+    }
+    else if (cachedIds.size > 0) {
+        warnings.push(`有 ${cachedIds.size} 条命中本地摘要缓存（这些条目不用再调 AI）；`
+            + '详情仍按缓存优先取一次——阈值指标只认流程详情数据，跳过详情会让阈值分组失效');
+    }
+    const finalGroups = groups.map((group) => {
+        if (group.id === PRIORITY_GROUP_ID) {
+            return {
+                id: group.id,
+                topPriority: true,
+                title: group.title,
+                count: group.count,
+                // 只有优先组默认展开，其余分组一律收缩。
+                defaultExpanded: true,
+                displayItems: requestItemsOf(group.requestDatas),
+            };
+        }
+        const byRequestId = new Map(group.requestDatas.map((item) => [item.requestId, item]));
+        const used = new Set();
+        const subGroups = [];
+        /**
+         * 「平铺」= 没有 ai二次分组：条目作为 `displayItems[]` 的 `type:"request"` 单条。
+         * 注意：不存在 `other` 兜底汇总项（2026-10-26 用户定稿），漏分 / 子组解散一律落到这里。
+         */
+        const singles = [];
+        const kind = detectBusinessKind(group.title);
+        const rawPlans = plans?.get(group.id) ?? [];
+        /** 意图是否适用于本组（Q15 专属/通用意图表）：不适用 = 按「没有意图」处理。 */
+        const groupHasFocus = hasFocus && focusAppliesToKind(groupFocus, kind);
+        /**
+         * aiGroups 什么时候被采纳：
+         *  - 意图适用于本组：只有本组有计划才分；没给计划 = 视为无意图，退回确定性规则（Q8）。
+         *  - 内部留言：有没有意图都采纳（无意图按流程标题分、有意图按详情+意图分，素材由 collect 准备）。
+         *  - 其余类型：意图不适用就一律忽略（Q9）。
+         */
+        const plansAllowed = groupHasFocus || kind === 'internal-message';
+        const groupPlans = plansAllowed ? rawPlans : [];
+        if (rawPlans.length > 0 && !plansAllowed) {
+            // 没有意图时不要说成「意图不适用于本类型」——那是误导，真实原因是本类型默认不做二次分组。
+            warnings.push(hasFocus
+                ? `「${group.title}」意图「${groupFocus}」不适用于本类型，已忽略 aiGroups，按无意图规则处理`
+                : `「${group.title}」${BUSINESS_KIND_LABEL[kind]}默认不按标题二次分组，已忽略 aiGroups（要按侧重点分组请在 groupFocus 里说明）`);
+        }
+        /** 该组整体平铺（不进入 ai二次分组）。 */
+        const flatReturn = () => ({
+            id: group.id,
+            topPriority: false,
+            title: group.title,
+            count: group.count,
+            defaultExpanded: false,
+            displayItems: requestItemsOf(group.requestDatas),
+        });
+        // D0 满意度类：不做 ai二次分组，也不与 AI 交互。
+        if (kind === 'satisfaction') {
+            if (rawPlans.length > 0)
+                warnings.push(`「${group.title}」满意度类不做 ai二次分组，已忽略 aiGroups`);
+            warnings.push(`「${group.title}」属于满意度类，全部平铺单条；summary 由标题兜底（不调 AI）`);
+            return flatReturn();
+        }
+        // D1 硬门槛：组内 <3 条一律平铺（即使给了 aiGroups 也忽略，不与 AI 交互）。
+        if (group.requestDatas.length < GROUP_MIN_ITEMS_FOR_SUBGROUP) {
+            if (rawPlans.length > 0)
+                warnings.push(`「${group.title}」不足 3 条（硬门槛），忽略 aiGroups 并平铺`);
+            return flatReturn();
+        }
+        // D2 意图适用但没给本组计划 = 视为没有意图（Q8：按阈值组/过期组等确定性规则）。
+        // 但**内部留言例外**：它 ≥3 条时没有「平铺」这个第三态（见下面的强制校验）。
+        if (groupHasFocus && groupPlans.length === 0 && kind !== 'internal-message') {
+            warnings.push(`「${group.title}」意图适用但模型未给本组计划，按无意图处理`);
+        }
+        /**
+         * 内部留言（Q1/Q16，2026-10-27 用户明确）：**≥3 条必然做 ai二次分组**，没有「平铺」这个第三态。
+         *
+         * 只有两种维度，且都必须由模型给出计划（CLI 不替模型分组）：
+         *  - 侧重点适用于内部留言 ⇒ 按「侧重点 + 流程详情数据」分组；
+         *  - 没有侧重点，或侧重点不适用 ⇒ **按流程标题分组**。
+         *
+         * 「没给计划」不是合法输入：静默平铺会把 200+ 条留言堆成一片（五年那批实测 223 条全平铺），
+         * 而且 warning 会被误读成「技术上无法分组」。这里直接要求补计划，保持规则单一确定性。
+         *
+         * 注意：门槛在前面 D1 已经判过（<3 条直接平铺），所以走到这里一定 ≥3 条。
+         */
+        if (kind === 'internal-message' && groupPlans.length === 0) {
+            throw workflowValidationError('ai_groups_required', `「${group.title}」属于内部留言且不少于 ${GROUP_MIN_ITEMS_FOR_SUBGROUP} 条，必须给本组 aiGroups：`
+                + (groupHasFocus
+                    ? `用户侧重点「${groupFocus}」适用于内部留言，请按侧重点结合流程详情数据分组`
+                    : '当前没有适用于内部留言的侧重点，请**按流程标题**分组（同主题的通知/公告归到同一子组）')
+                + `；可用 groupId：${group.id}，组内序号 1..${group.requestDatas.length}`, {
+                retryAllowed: true,
+                details: { groupId: group.id, count: group.requestDatas.length, groupFocus: groupHasFocus ? groupFocus : '' },
+            });
+        }
+        if (groupPlans.length === 0) {
+            // 无意图（或退回无意图）：只有四类确定性规则，其余一律平铺。
+            if (kind === 'leave' || kind === 'finance') {
+                // 请假/财务：最多一个固定组；指标**只来自流程详情数据**，取不到的条目单独平铺（Q3/Q11）。
+                const eligible = [];
+                let unknown = 0;
+                for (const row of group.requestDatas) {
+                    const metric = rowMetricsOf(row, metrics);
+                    const value = kind === 'leave' ? metric.leaveDays : metric.amount;
+                    const hit = kind === 'leave'
+                        ? (typeof value === 'number' && value <= LEAVE_DAY_THRESHOLD)
+                        : (typeof value === 'number' && value > 0 && value <= FINANCE_AMOUNT_THRESHOLD);
+                    if (hit)
+                        eligible.push(row);
+                    else {
+                        singles.push(row);
+                        if (typeof value !== 'number')
+                            unknown += 1;
+                    }
+                }
+                if (eligible.length > 0) {
+                    subGroups.push({
+                        title: kind === 'leave' ? LEAVE_GROUP_TITLE : FINANCE_GROUP_TITLE,
+                        requestDatas: eligible,
+                    });
+                    warnings.push(`「${group.title}」按${kind === 'leave' ? '请假类 1天以内' : '财务类 100元以内'}确定性汇总，其余条目平铺`);
+                }
+                if (unknown > 0) {
+                    warnings.push(`「${group.title}」有 ${unknown} 条流程详情数据取不到${kind === 'leave' ? '请假天数' : '报销金额'}，不做 ai二次分组、按单条平铺`);
+                }
+            }
+            else if (kind === 'issue-support') {
+                // 问题支持类：判据是**原始列表数据**的超时字段 userOverTime（Q4）；无命中则整组平铺。
+                const urgentRows = [];
+                const rest = [];
+                for (const row of group.requestDatas) {
+                    if (isExpiredUserOverTime(row.userOverTime) || isExpiringTodayRow(row))
+                        urgentRows.push(row);
+                    else
+                        rest.push(row);
+                }
+                singles.push(...rest);
+                if (urgentRows.length > 0) {
+                    subGroups.push({ title: ISSUE_SUPPORT_GROUP_TITLE, requestDatas: urgentRows });
+                    warnings.push(`「${group.title}」按客户问题支持类口径：${urgentRows.length} 条已过期或今日到期，其余 ${rest.length} 条平铺`);
+                }
+                else {
+                    warnings.push(`「${group.title}」没有已过期或今日到期的条目（userOverTime 未命中），全部平铺`);
+                }
+            }
+            else {
+                singles.push(...group.requestDatas);
+                warnings.push(`「${group.title}」默认不做 ai二次分组，${group.requestDatas.length} 条平铺`);
+            }
+        }
+        else {
+            // 采纳 aiGroups：按计划切，之后统一做「子组 <2 解散」与「漏分平铺」。
+            /**
+             * 保留标题（`1天以内` / `100元以内`）是 **CLI 自己造的阈值组名**，带「≤阈值」的语义。
+             * 模型若拿它当子组名，CLI 必须逐条核阈值——否则 2000 元的报销会出现在「100元以内」里。
+             * 超阈值的条目剔出、转单条展示（一条都不丢），并点名。
+             */
+            const reservedTitle = kind === 'leave'
+                ? LEAVE_GROUP_TITLE
+                : kind === 'finance' ? FINANCE_GROUP_TITLE : '';
+            const droppedByThreshold = [];
+            for (const plan of groupPlans) {
+                const datas = [];
+                // `seq`（组内 1-based 序号）→ requestId：映射口径与 `groupingBrief[].items[].idx` 一致。
+                const planRequestIds = plan.requestIds.length > 0
+                    ? plan.requestIds
+                    : plan.seq.map((n) => {
+                        const row = group.requestDatas[n - 1];
+                        if (!row) {
+                            throw workflowValidationError('ai_group_seq_out_of_range', `aiGroups 给「${group.title}」的 seq 里有 ${n}，但该组只有 ${group.requestDatas.length} 条（序号从 1 开始）`, { retryAllowed: true, details: { groupId: group.id, seq: n, count: group.requestDatas.length } });
+                        }
+                        return row.requestId;
+                    });
+                for (const requestId of planRequestIds) {
+                    const data = byRequestId.get(requestId);
+                    if (!data) {
+                        throw workflowValidationError('ai_group_unknown_request', `aiGroups 把 requestId「${requestId}」分到了「${group.title}」，但该组没有这条数据（可能组 id 串了，或 id 不是字符串）`, { retryAllowed: true, details: { groupId: group.id, requestId } });
+                    }
+                    if (used.has(requestId)) {
+                        throw workflowValidationError('ai_group_duplicate_request', `requestId「${requestId}」在「${group.title}」里被分进了多个子组，每条数据只能属于一个汇总项`, { retryAllowed: true, details: { groupId: group.id, requestId } });
+                    }
+                    used.add(requestId);
+                    datas.push(data);
+                }
+                // 保留标题 ⇒ 逐条核阈值（超阈值的剔出，稍后平铺）
+                let groupRows = datas;
+                if (reservedTitle && plan.title === reservedTitle) {
+                    const kept = [];
+                    const dropped = [];
+                    for (const row of datas) {
+                        const metric = rowMetricsOf(row, metrics);
+                        const value = kind === 'leave' ? metric.leaveDays : metric.amount;
+                        const hit = kind === 'leave'
+                            ? (typeof value === 'number' && value <= LEAVE_DAY_THRESHOLD)
+                            : (typeof value === 'number' && value > 0 && value <= FINANCE_AMOUNT_THRESHOLD);
+                        (hit ? kept : dropped).push(row);
+                    }
+                    if (dropped.length > 0) {
+                        droppedByThreshold.push(...dropped);
+                        warnings.push(`「${group.title}」的「${plan.title}」子组有 ${dropped.length} 条不满足阈值，已剔除并改为单条展示`);
+                    }
+                    groupRows = kept;
+                }
+                subGroups.push({ title: plan.title, requestDatas: groupRows });
+            }
+            // 子组 <2 不成立（含有意图的子组）：解散，条目平铺（Q5）。
+            const kept = subGroups.filter((sub) => sub.requestDatas.length >= 2);
+            const dissolved = subGroups.length - kept.length;
+            if (dissolved > 0) {
+                for (const sub of subGroups) {
+                    if (sub.requestDatas.length < 2)
+                        singles.push(...sub.requestDatas);
+                }
+                subGroups.length = 0;
+                subGroups.push(...kept);
+                warnings.push(`「${group.title}」有 ${dissolved} 个子组不足 2 条，已解散并平铺这些条目`);
+            }
+            // 保留标题里被阈值剔除的条目：平铺，且不能再被算成「漏分」。
+            if (droppedByThreshold.length > 0)
+                singles.push(...droppedByThreshold);
+            // AI 漏分的条目：直接平铺，**不建 other 汇总项**（Q12）。
+            const uncovered = group.requestDatas.filter((item) => !used.has(item.requestId));
+            if (uncovered.length > 0) {
+                singles.push(...uncovered);
+                warnings.push(`「${group.title}」有 ${uncovered.length} 条未被 AI 分组，按单条平铺（不造 other 子组）`);
+            }
+        }
+        // 条数降序；sort 稳定，同条数保持 AI 给出的先后顺序。
+        // 有侧重点时沿用模型顺序；没有侧重点时按条数降序。
+        if (!groupHasFocus)
+            subGroups.sort((a, b) => b.requestDatas.length - a.requestDatas.length);
+        const groupItems = subGroups.map((sub, index) => ({
+            // 键顺序照新目标结构：type → id → title → count → summary → defaultExpanded → requestDatas
+            type: 'group',
+            id: `${group.id}-${index + 1}`,
+            title: sub.title,
+            count: sub.requestDatas.length,
+            // 组摘要口径不变（Q4）：只有 CLI 自己造的三类固定组用固定文案；AI 子组一律留空交 groupSummary。
+            summary: ((kind === 'leave' && sub.title === LEAVE_GROUP_TITLE)
+                || (kind === 'finance' && sub.title === FINANCE_GROUP_TITLE)
+                || (kind === 'issue-support' && sub.title === ISSUE_SUPPORT_GROUP_TITLE))
+                ? (deterministicGroupSummary(kind, sub.requestDatas, metrics, singles.length) ?? '')
+                : '',
+            // 汇总项自身默认收缩（与大分组的展开状态互相独立）
+            defaultExpanded: false,
+            requestDatas: sub.requestDatas,
+        }));
+        return {
+            id: group.id,
+            topPriority: false,
+            title: group.title,
+            count: group.count,
+            defaultExpanded: false,
+            // 汇总项在前、单独条目在后。
+            displayItems: [...groupItems, ...requestItemsOf(singles)],
+        };
+    });
+    // 分组顺序完全沿用第一次 workflowName 分组顺序。
+    const orderedGroups = finalGroups;
+    if (plans === undefined) {
+        warnings.push('smartGroup 未收到 aiGroups：已按业务类型执行确定性分组；需要语义侧重点时再传入本轮 aiGroups');
+    }
+    return {
+        data: {
+            smartSummaryTitle: base.smartSummaryTitle,
+            totalCount: totalTodoCount(orderedGroups),
+            wfIdGroup: orderedGroups,
+        },
+        warnings,
+        facts,
+    };
+}