weaver-work-cli 0.1.39 → 0.1.42

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

@@ -115,29 +115,32 @@ export function isExpiringTodayRow(row, now = Date.now()) {
     return isExpiringTodayUserOverTime(row.userOverTime, now);
 }
 /**
- * 「建议优先处理的流程」筛选规则：
+ * 「建议优先处理的流程」筛选规则（2026-11-03 起可在 `generalRules.priorityGroup.rules` 配置启用子集）：
  *
- *  1. **超时** 必收（`userOverTime` / `overTime` 判定，与紧急程度无关）；
- *  2. **紧急程度**按 `requestLevel` 取：整批有 `=2`（紧急）就只要 2；没有 2 才退到 `=1`（重要）；
+ *  1. **超时**（`overdue`）必收（`userOverTime` / `overTime` 判定，与紧急程度无关）；
+ *  2. **紧急程度**（`levelFallback`）按 `requestLevel` 取：整批有 `=2`（紧急）就只要 2；没有 2 才退到 `=1`（重要）；
  *     `=0`（正常）**不因等级入选**——降级链到 1 就停，不倒到 0；
  *  3. 整批连 1 级都没有（全 0）时，等级条件不生效，只按超时筛；此时若一条都没超时，
  *     优先组为空（"实在没有紧急的就算了"），不硬凑。
  *
  * 注意这是**筛选**，不是视图叠加：入选条目的 `requestLevel` 只有 2（或 2 缺失时的 1）与超时两类。
+ * `enabledRules` 缺省 = 全部启用（与历史行为一致）；预留 `expiringToday`（今天到期）等后续扩展。
  */
-export function selectPriorityRows(rows) {
+export function selectPriorityRows(rows, enabledRules) {
+    const rules = enabledRules ?? new Set(['overdue', 'levelFallback']);
     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 targetLevel = rules.has('levelFallback') && maxLevel >= 2 ? 2
+        : rules.has('levelFallback') && 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 overdue = rules.has('overdue') && isOverdueRow(row);
         const byLevel = targetLevel !== undefined && row.requestLevel >= targetLevel;
         if (overdue)
             overdueCount += 1;
@@ -323,12 +326,11 @@ export function runGroup(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;
+    // 2026-11-03 用户定：分组阶段**不再**产出「建议优先处理的流程」——它是最终结构上的一个置顶
+    // 视图，等摘要全部回填后用 `assemblePriorityGroup()` 按同一条规则从成品数据里筛出来。
+    // 这样前期（摘要单位、闸门、统计）都只需处理一份数据，不必到处特判 topPriority。
     const buckets = new Map();
-    for (const row of restRows) {
+    for (const row of rows) {
         const key = groupKeyOf(row, groupBy);
         let bucket = buckets.get(key);
         if (!bucket) {
@@ -356,20 +358,8 @@ export function runGroup(args) {
         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 groups = workflowGroups;
+    const displayed = workflowGroups.slice(0, topN);
     const rest = workflowGroups.slice(topN);
     const restCount = rest.reduce((sum, group) => sum + group.count, 0);
     const overall = statsOf(rows);
@@ -386,20 +376,6 @@ export function runGroup(args) {
             ? `有 ${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 中（未截断）`);
     }
@@ -434,7 +410,7 @@ export function runGroup(args) {
         },
         wfIdGroup: groups,
         /** 第二部分（非优先组）的总条数与组数，前端折叠/分页直接用它，不用自己减 */
-        restTotal: restRows.length,
+        restTotal: rows.length,
         restGroupCount: workflowGroups.length,
         restGroups: rest.length > 0 ? { groupCount: rest.length, count: restCount } : null,
         warnings,

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

@@ -69,8 +69,9 @@ export function collectGroupSummaryBatches(groups, isCtxEmpty, maxCharsFor = ()
             continue;
         const kind = detectBusinessKind(group.title);
         for (const sub of groupItemsOf(group)) {
-            // CLI 已经写好固定文案 ⇒ 不需要模型再写一遍
-            if (isDeterministicGroupKind(kind) && (sub.summary ?? '').trim() !== '')
+            // 已有摘要就不产批次：①CLI 固定文案（needAI:false）；②模型随 aiGroups 一起给的
+            // 子组摘要（2026-11-03 合并交互）——两者都不需要再问一次模型。
+            if ((sub.summary ?? '').trim() !== '')
                 continue;
             const allRows = Array.isArray(sub.requestDatas) ? sub.requestDatas : [];
             const rows = isCtxEmpty ? allRows.filter((row) => !isCtxEmpty(row.requestId)) : allRows;

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

@@ -5,8 +5,9 @@ import { collectRawTodos } from './todoSmartConvert.collect.js';
 import { runSmartConvert } from './todoSmartConvert.aggregate.js';
 import { runGroup } from './todoSmartConvert.group.js';
 import { inferStage, readStage } from './todoSmartConvert.pipeline.js';
-import { runSmartGroup } from './todoSmartConvert.smartGroup.js';
+import { runSmartGroup, assemblePriorityGroup } from './todoSmartConvert.smartGroup.js';
 import { runSummary, runSummaryContext } from './todoSmartConvert.summary.js';
+import { runSubGroup } from './todoSmartConvert.subGroup.js';
 import { runGroupSummary, runGroupSummaryContext } from './todoSmartConvert.groupSummary.js';
 import { schemaOf, } from '../types.js';
 const inputSchema = schemaOf({
@@ -58,6 +59,7 @@ const inputSchema = schemaOf({
         },
     },
     withDetailContext: { type: 'boolean', description: 'smartGroup 是否同进程生成单条摘要上下文。' },
+    withSubGroup: { type: 'boolean', description: 'summary 回填后是否同进程接着做 ai 二次分组（stage=subGroup 等价）。' },
     withGroupSummaryContext: { type: 'boolean', description: 'summary 是否同进程生成组摘要上下文。' },
     detailPrefetch: { type: 'boolean', description: '废弃兼容参数，已忽略；collect 只在给了 groupFocus 且意图适用于本组时按需预取分组字段（走详情缓存）。' },
     groupBy: { type: 'string', enum: [...GROUP_BY_VALUES], default: 'workflow' },
@@ -80,6 +82,7 @@ const inputSchema = schemaOf({
     tabid: { type: 'string' },
     tabName: { type: 'string' },
     subCategory: { type: 'string' },
+    isremarks: { type: 'string', description: '备注筛选（getTodoListData params.isremarks），多个数字用英文逗号拼接，仅作用于本汇总取数' },
     workflow: { type: 'array', items: { type: 'string' } },
     creator: { type: 'string' },
     requestName: { type: 'string' },
@@ -139,6 +142,19 @@ export const workflowTodoSmartConvertOperations = [{
                 : readStage(args.stage);
             const hasItems = Array.isArray(args.items);
             const resumed = stage === 'collect' && hasItems;
+            /**
+             * 把「建议优先处理的流程」拼到**最终结构**上（2026-11-03 用户定：放到最后生成）。
+             * 只在会产出成品结构的阶段（summary / groupSummary）调用；幂等，重复调用不会叠加。
+             */
+            const withPriorityView = (data, extraWarnings) => {
+                if ((args.groupBy ?? 'workflow') !== 'workflow')
+                    return { data, warnings: extraWarnings };
+                const { groups, warning } = assemblePriorityGroup(data.wfIdGroup ?? []);
+                return {
+                    data: { ...data, wfIdGroup: groups },
+                    warnings: warning ? [...extraWarnings, warning] : extraWarnings,
+                };
+            };
             if ((stage === 'group' || stage === 'smartGroup' || stage === 'aggregate') && !hasItems) {
                 throw workflowValidationError('items_required', 'stage=' + stage + ' 需要 items：先执行 stage=collect，再回灌 data.items', { retryAllowed: false });
             }
@@ -166,28 +182,48 @@ export const workflowTodoSmartConvertOperations = [{
                     throw workflowValidationError('ai_summaries_required', 'stage=summary 需要 aiSummaries：先执行 stage=summaryContext', { retryAllowed: false });
                 }
                 const result = await runSummary(args, env);
+                // 2026-11-03 用户定：**ai 二次分组后移到单条摘要之后**（两者不再耦合）。
+                // `withSubGroup` 时在同一次进程内接着做二次分组，省掉一轮 CLI 启动（≈6~7s）。
+                // 顺序：summary(回填单条摘要) → subGroup(切子组) → priority 装配 → 组摘要批次。
+                let baseData = result.data;
+                let baseWarnings = result.warnings;
+                let subGrouped = false;
+                if (args.withSubGroup === true) {
+                    const sub = await runSubGroup({ ...args, wfIdGroup: baseData.wfIdGroup }, env);
+                    baseData = { ...baseData, wfIdGroup: sub.data.wfIdGroup };
+                    baseWarnings = [...baseWarnings, ...sub.warnings];
+                    subGrouped = true;
+                }
+                const final = withPriorityView(baseData, baseWarnings);
                 if (args.withGroupSummaryContext === true) {
                     const context = await runGroupSummaryContext({
-                        wfIdGroup: result.data.wfIdGroup,
-                        smartSummaryTitle: result.data.smartSummaryTitle,
-                        totalCount: result.data.totalCount,
+                        wfIdGroup: final.data.wfIdGroup,
+                        smartSummaryTitle: final.data.smartSummaryTitle,
+                        totalCount: final.data.totalCount,
                     }, env);
                     if (Array.isArray(context.data.groupSummaryBatches) && context.data.groupSummaryBatches.length === 0) {
-                        return finish(env, args, startedAt, stage, result.data, {
-                            branch: 'todo-smart-convert', stage, aiSummarized: true, withGroupSummaryContext: true, ...result.meta,
-                        }, result.warnings);
+                        return finish(env, args, startedAt, stage, final.data, {
+                            branch: 'todo-smart-convert', stage, aiSummarized: true, subGrouped, withGroupSummaryContext: true, ...result.meta,
+                        }, final.warnings);
                     }
                     return finish(env, args, startedAt, stage, {
-                        ...result.data,
+                        ...final.data,
                         groupSummaryBatches: context.data.groupSummaryBatches,
                         groupSummaryStats: context.data.groupSummaryStats,
                     }, {
-                        branch: 'todo-smart-convert', stage, aiSummarized: true, withGroupSummaryContext: true, ...result.meta,
-                    }, [...result.warnings, ...context.warnings]);
+                        branch: 'todo-smart-convert', stage, aiSummarized: true, subGrouped, withGroupSummaryContext: true, ...result.meta,
+                    }, [...final.warnings, ...context.warnings]);
                 }
-                return finish(env, args, startedAt, stage, result.data, {
-                    branch: 'todo-smart-convert', stage, aiSummarized: true, ...result.meta,
-                }, result.warnings);
+                return finish(env, args, startedAt, stage, final.data, {
+                    branch: 'todo-smart-convert', stage, aiSummarized: true, subGrouped, ...result.meta,
+                }, final.warnings);
+            }
+            if (stage === 'subGroup') {
+                const result = await runSubGroup(args, env);
+                const final = withPriorityView(result.data, result.warnings);
+                return finish(env, args, startedAt, stage, final.data, {
+                    branch: 'todo-smart-convert', stage, aiGrouped: Array.isArray(args.aiGroups), subGrouped: true,
+                }, final.warnings);
             }
             if (stage === 'groupSummaryContext') {
                 const result = await runGroupSummaryContext(args, env);
@@ -200,9 +236,10 @@ export const workflowTodoSmartConvertOperations = [{
                     throw workflowValidationError('ai_group_summaries_required', 'stage=groupSummary 需要 aiGroupSummaries：先执行 stage=groupSummaryContext', { retryAllowed: false });
                 }
                 const result = await runGroupSummary(args, env);
-                return finish(env, args, startedAt, stage, result.data, {
+                const final = withPriorityView(result.data, result.warnings);
+                return finish(env, args, startedAt, stage, final.data, {
                     branch: 'todo-smart-convert', stage, aiSummarized: true, ...result.meta,
-                }, result.warnings);
+                }, final.warnings);
             }
             if (stage === 'group' || resumed) {
                 return finish(env, args, startedAt, 'group', runGroup(args), {

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

@@ -32,7 +32,22 @@ export function inferStage(args) {
         return 'groupSummary';
     if (Array.isArray(args.aiSummaries))
         return 'summary';
-    return hasAnyRequestSummary(args.wfIdGroup) ? 'groupSummaryContext' : 'summaryContext';
+    if (hasAnyRequestSummary(args.wfIdGroup)) {
+        // 2026-11-03：ai 二次分组后移到单条摘要之后。
+        // 单条摘要已填、但结构里还没有汇总项（`type:"group"`）⇒ 下一步是 subGroup；
+        // 已经有汇总项 ⇒ 说明二次分组做过，下一步才是组摘要。
+        return hasAnySubGroup(args.wfIdGroup) ? 'groupSummaryContext' : 'subGroup';
+    }
+    return 'summaryContext';
+}
+/** 结构里是否已经存在汇总项（`displayItems[].type === "group"`）。 */
+export function hasAnySubGroup(groups) {
+    for (const raw of groups) {
+        const items = raw?.displayItems;
+        if (Array.isArray(items) && items.some((item) => item?.type === 'group'))
+            return true;
+    }
+    return false;
 }
 /** 从**未经校验**的分组对象里摊平出条目（推断阶段用，同时兼容新旧两种结构）。 */
 export function rowsOfRawGroup(group) {

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

@@ -1,9 +1,9 @@
 import { workflowValidationError } from '../../errors.js';
 import { renderGroupSummaryTemplate, } from './businessRules.js';
 import { asRecord, readBoundedInt, } from './todoSmartConvert.core.js';
-import { PRIORITY_GROUP_ID, PRIORITY_GROUP_TITLE, runGroup, GROUP_MIN_ITEMS_FOR_SUBGROUP, } from './todoSmartConvert.group.js';
+import { PRIORITY_GROUP_ID, PRIORITY_GROUP_TITLE, runGroup, GROUP_MIN_ITEMS_FOR_SUBGROUP, selectPriorityRows, sortPriorityRows, } from './todoSmartConvert.group.js';
 import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
-import { activeRuleFor, evaluateFocusKeywords, primeRules } from './aigroupRules.js';
+import { activeRuleFor, evaluateFocusKeywords, generalRules, primeRules } from './aigroupRules.js';
 import { openSummaryCache, promptTagOf } from './summaryCache.js';
 import { openDetailCache, detailMaterialTagOf } from './todoDetailCache.js';
 const DEFAULT_REQUEST_SUMMARY_MAX = 50;
@@ -19,6 +19,54 @@ export function rowsOfGroup(group) {
 export function groupItemsOf(group) {
     return group.displayItems.filter((item) => item.type === 'group');
 }
+/**
+ * 最终结构上的「建议优先处理的流程」置顶视图（2026-11-03 用户定：改到**最后一步**生成）。
+ *
+ * - 输入是**成品结构**（单条摘要、组摘要都已回填）：按同一条规则（`generalRules.priorityGroup`）
+ *   从各工作流分组的 `displayItems` 里摊平条目、筛出「超时 / 紧急程度」命中项，复制一份成
+ *   `id=priority`、`unshift` 到首位；
+ * - **幂等**：输入里已有 priority 组时先剔除再重建，stage 串联多次调用结果一致；
+ * - 叠加视图语义不变：入选条目仍保留在原工作流分组里 ⇒ `Σcount` 仍大于 `totalCount`
+ *   （`totalCount` 始终按去重条数计）；
+ * - 判定字段（`overTime` / `userOverTime` / `requestLevel`）都在 `requestData` 上，不必回查列表；
+ *   原排序用的 `receivedTime` 不在 requestData 中，同档退化为按 `requestId` 稳定排序。
+ */
+export function assemblePriorityGroup(groups) {
+    const base = (groups ?? []).filter((group) => group.id !== PRIORITY_GROUP_ID && group.topPriority !== true);
+    const pgConfig = generalRules()?.priorityGroup ?? null;
+    const title = pgConfig?.title?.trim() || PRIORITY_GROUP_TITLE;
+    const rules = new Set(pgConfig?.rules ?? ['overdue', 'levelFallback']);
+    const rows = base.flatMap((group) => rowsOfGroup(group));
+    if (rows.length === 0)
+        return { groups: base };
+    const selection = selectPriorityRows(rows, rules);
+    const selected = sortPriorityRows(selection.rows);
+    if (selected.length === 0) {
+        return { groups: base, warning: `本次没有超时条目，也没有 requestLevel≥1 的条目，故不输出「${title}」分组` };
+    }
+    const levelText = selection.targetLevel === 2
+        ? '紧急（requestLevel=2）'
+        : selection.targetLevel === 1
+            ? '重要（requestLevel=1；本次无 2 级数据，已按规则降级取 1，0 级不取）'
+            : '无等级（本次整批没有 ≥1 级的条目，只按超时筛）';
+    const priorityGroup = {
+        id: PRIORITY_GROUP_ID,
+        topPriority: true,
+        title,
+        count: selected.length,
+        // 大分组（含优先组）默认展开；只有汇总项收缩
+        defaultExpanded: true,
+        // 复制一份：优先组是独立视图，确保两边互不影响
+        displayItems: requestItemsOf(selected.map((row) => ({ ...row }))),
+    };
+    return {
+        groups: [priorityGroup, ...base],
+        warning: `「${title}」筛出 ${selected.length} 条：超时 ${selection.overdueCount} 条 / `
+            + `等级命中 ${selection.levelCount} 条（两者都满足 ${selection.bothCount} 条），等级口径=${levelText}；`
+            + `这 ${selected.length} 条同时保留在各自工作流分组中（叠加视图：Σcount 会大于 totalCount，`
+            + 'totalCount 按去重条数计）',
+    };
+}
 /**
  * 校验并索引 `aiGroups`。
  *
@@ -40,10 +88,11 @@ export function readAiGroups(value) {
         if (!record) {
             throw workflowValidationError('ai_groups_invalid', `${label} 必须是对象 { groupId, title, requestIds }`, { retryAllowed: false });
         }
-        const unknownKeys = Object.keys(record).filter((key) => !['groupId', 'title', 'requestIds'].includes(key));
+        const unknownKeys = Object.keys(record).filter((key) => !['groupId', 'title', 'requestIds', 'summary'].includes(key));
         if (unknownKeys.length > 0) {
-            throw workflowValidationError('ai_groups_invalid', `${label} 不接受字段：${unknownKeys.join(', ')}；只支持 groupId / title / requestIds`, { retryAllowed: false, details: { unknownKeys } });
+            throw workflowValidationError('ai_groups_invalid', `${label} 不接受字段：${unknownKeys.join(', ')}；只支持 groupId / title / requestIds / summary`, { retryAllowed: false, details: { unknownKeys } });
         }
+        const planSummary = typeof record.summary === 'string' ? record.summary.trim() : '';
         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 });
@@ -65,7 +114,12 @@ export function readAiGroups(value) {
             ids.push(id);
         }
         const bucket = map.get(groupId) ?? [];
-        bucket.push({ groupId, title, requestIds: [...new Set(ids)] });
+        bucket.push({
+            groupId,
+            title,
+            requestIds: [...new Set(ids)],
+            ...(planSummary ? { summary: planSummary } : {}),
+        });
         map.set(groupId, bucket);
     });
     return map;
@@ -159,48 +213,29 @@ function rowKeyForCount(row) {
         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 detailCacheForTag = skipDetail ? null : await openDetailCache(env.ctx);
-    const materialTagOfRow = (requestId, stamp) => {
-        const entry = detailCacheForTag?.get(requestId, stamp);
-        return entry ? detailMaterialTagOf(entry) : undefined;
-    };
-    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, promptTagOf(activeRuleFor(group.title)?.requestSummaryPrompt ?? ''), materialTagOfRow(row.requestId, row.lastFeedBackDateTime)))
-                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));
+/** 平铺结构：不做 ai 二次分组，`displayItems` 全是单条。 */
+export function flattenFinalGroups(groups) {
+    return groups.map((group) => ({
+        id: group.id,
+        topPriority: group.id === PRIORITY_GROUP_ID,
+        title: group.title,
+        count: group.count,
+        defaultExpanded: true,
+        displayItems: requestItemsOf(group.requestDatas),
+    }));
+}
+/**
+ * 在**已有结构**上应用 aigroup 规则的 ai 二次分组（2026-11-03 解耦）。
+ *
+ * 输入是首次 workflowName 分组产出的平铺结构（条目上可能已经带着单条摘要），
+ * 输出带汇总项的结构；既不重新分组、也不碰详情缓存，纯粹做「组内切子组」。
+ */
+export function applySubGroups(groups, options) {
+    const plans = options.plans;
+    const facts = options.facts;
+    const metrics = options.metrics;
+    const warnings = options.warnings;
+    // 计划本身的合法性：未知 groupId / 对优先组做二次分组，都要硬失败（2026-11-03 迁移到本阶段）。
     const knownGroupIds = new Set(groups.map((group) => group.id));
     for (const groupId of plans?.keys() ?? []) {
         if (!knownGroupIds.has(groupId)) {
@@ -210,18 +245,6 @@ export async function runSmartGroup(args, env, options = {}) {
             throw workflowValidationError('ai_group_priority_unsupported', `「${PRIORITY_GROUP_TITLE}」不做二次分组：目标结构里它只有 displayItems（全是单条展示），没有汇总项；请把它的条目从 aiGroups 里去掉`, { retryAllowed: true });
         }
     }
-    // markdown 是中间态的东西，最终结构里没有，相关提示一并丢掉，免得误导调用方。
-    const warnings = (base.warnings ?? [])
-        .filter((text) => !text.startsWith('markdown 只展示前'));
-    // aigroup 规则（default.json + user-intents.json）：每个 operation 只加载一次。
-    warnings.push(...primeRules(env.ctx).warnings);
-    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 {
@@ -358,7 +381,11 @@ export async function runSmartGroup(args, env, options = {}) {
                     }
                     groupRows = kept;
                 }
-                subGroups.push({ title: plan.title, requestDatas: groupRows });
+                subGroups.push({
+                    title: plan.title,
+                    requestDatas: groupRows,
+                    ...(plan.summary ? { summary: plan.summary } : {}),
+                });
             }
             // 子组 <2 不成立（含有意图的子组）：解散，条目平铺（Q5）。
             const kept = subGroups.filter((sub) => sub.requestDatas.length >= 2);
@@ -400,6 +427,10 @@ export async function runSmartGroup(args, env, options = {}) {
         }
         /** 组摘要：规则 `needAI:false` 时用 JSON `template` 渲染，否则留空交 AI。 */
         const renderSubGroupSummary = (sub) => {
+            // ① 模型随 aiGroups 一起给的摘要优先（同一次交互产出，见 AiSmartGroupPlan.summary）
+            if ((sub.summary ?? '').trim())
+                return sub.summary;
+            // ② 否则走规则里的固定模板（needAI:false 的确定性组）
             const groupSummary = rule.aiGroup?.groupSummary;
             if (!groupSummary || groupSummary.needAI || !groupSummary.template)
                 return '';
@@ -449,10 +480,67 @@ export async function runSmartGroup(args, env, options = {}) {
             displayItems: [...groupItems, ...requestItemsOf(singles)],
         };
     });
+    return finalGroups;
+}
+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 detailCacheForTag = skipDetail ? null : await openDetailCache(env.ctx);
+    const materialTagOfRow = (requestId, stamp) => {
+        const entry = detailCacheForTag?.get(requestId, stamp);
+        return entry ? detailMaterialTagOf(entry) : undefined;
+    };
+    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, promptTagOf(activeRuleFor(group.title)?.requestSummaryPrompt ?? ''), materialTagOfRow(row.requestId, row.lastFeedBackDateTime)))
+                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);
+    // markdown 是中间态的东西，最终结构里没有，相关提示一并丢掉，免得误导调用方。
+    const warnings = (base.warnings ?? [])
+        .filter((text) => !text.startsWith('markdown 只展示前'));
+    // aigroup 规则（default.json + user-intents.json）：每个 operation 只加载一次。
+    warnings.push(...primeRules(env.ctx).warnings);
+    if (skipDetail) {
+        warnings.push('withDetailContext=false：本次未拉取任何详情——请假/财务阈值改为按标题识别、跳过整组空判定，也不产 summaryBatches');
+    }
+    else if (cachedIds.size > 0) {
+        warnings.push(`有 ${cachedIds.size} 条命中本地摘要缓存（这些条目不用再调 AI）；`
+            + '详情仍按缓存优先取一次——阈值指标只认流程详情数据，跳过详情会让阈值分组失效');
+    }
     // 分组顺序完全沿用第一次 workflowName 分组顺序。
-    const orderedGroups = finalGroups;
-    if (plans === undefined) {
-        warnings.push('smartGroup 未收到 aiGroups：已按业务类型执行确定性分组；需要语义侧重点时再传入本轮 aiGroups');
+    // 2026-11-03 用户定：本阶段**只做** workflowName 首次分组，产出平铺 displayItems。
+    // ai 二次分组一律由 `stage=subGroup` 调 `applySubGroups()` 完成（旧的就地分组分支已删除）。
+    const orderedGroups = flattenFinalGroups(groups);
+    if (plans !== undefined) {
+        warnings.push('aiGroups 已收到，但本阶段不做二次分组：留到 stage=subGroup 应用');
     }
     return {
         data: {

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

@@ -0,0 +1,56 @@
+import { applySubGroups, metricsOfFacts, readAiGroups, rowsOfGroup, totalTodoCount, } from './todoSmartConvert.smartGroup.js';
+import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
+import { readFinalGroups, readSmartSummaryTitle } from './todoSmartConvert.summary.js';
+/**
+ * `stage=subGroup`：**ai 二次分组**（2026-11-03 从 `smartGroup` 拆出来独立成阶段）。
+ *
+ * 为什么要拆：二次分组曾经和「workflowName 首次分组」绑在同一个 stage 里，导致
+ * `focus:false` 的组在**写单条摘要之前**就强制要求模型给出 `aiGroups`——摘要与分组互相耦合。
+ * 现在的链路：
+ *
+ * ```
+ * collect → smartGroup(仅首次分组 + 平铺) → summaryContext → summary(单条摘要)
+ *         → subGroup(本阶段：ai 二次分组) → groupSummaryContext → groupSummary
+ * ```
+ *
+ * 本阶段只做「组内切子组」：不重新分组、不改摘要、详情全部走缓存（命中率 100%，
+ * 因为 collect 已经全量回填）。条目上已有的单条摘要随 `requestDatas` 一起带进子组。
+ */
+export async function runSubGroup(args, env) {
+    const groups = await readFinalGroups(args, env);
+    const warnings = [];
+    // 优先级组是最终结构上的叠加视图，不参与二次分组（导出前由 assemblePriorityGroup 重建）。
+    const wfGroups = groups
+        .filter((group) => !group.topPriority)
+        .map((group) => ({
+        id: group.id,
+        title: group.title,
+        count: group.count,
+        requestDatas: rowsOfGroup(group),
+    }));
+    const plans = args.aiGroups === undefined || args.aiGroups === null
+        ? undefined
+        : readAiGroups(args.aiGroups);
+    // 阈值类二次分组（请假天数 / 报销金额 / 计划完成时间）要指标 ⇒ 仍要详情；
+    // collect 已全量回填，这里等价于纯缓存命中、零 HTTP。
+    const rows = wfGroups.flatMap((group) => group.requestDatas);
+    const detailIds = [...new Set(rows.map((row) => row.requestId).filter(Boolean))];
+    const facts = new Map();
+    let metrics;
+    if (args.withDetailContext !== false && detailIds.length > 0) {
+        const result = await fetchDetailFacts(env, detailIds, args, stampsOfRows(rows));
+        for (const [requestId, fact] of result.facts)
+            facts.set(requestId, fact);
+        metrics = metricsOfFacts(facts);
+        warnings.push(...result.warnings);
+    }
+    const finalGroups = applySubGroups(wfGroups, { plans, facts, metrics, warnings });
+    return {
+        data: {
+            smartSummaryTitle: readSmartSummaryTitle(args, `您当前有 ${totalTodoCount(groups)} 条待办，清单如下：`),
+            totalCount: totalTodoCount(groups),
+            wfIdGroup: finalGroups,
+        },
+        warnings,
+    };
+}