weaver-work-cli 0.1.31 → 0.1.33

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

@@ -1,12 +1,12 @@
+import { activeRuleFor } from './aigroupRules.js';
 import { WORKFLOW_ENDPOINTS } from '../../endpoints.js';
 import { saveSearchIndex } from '../../state.js';
 import { buildSearchQuery } from '../read.js';
 import { projectDisplayRows } from './todoListRows.js';
 import { responseData } from '../shared.js';
 import { openSummaryCache, SUMMARY_CACHE_FILE_NAME } from './summaryCache.js';
-import { detectBusinessKind } from './businessRules.js';
 import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
-import { focusAppliesToKind, GROUP_MIN_ITEMS_FOR_SUBGROUP, isExpiringTodayRow, isOverdueRow, runGroup, } from './todoSmartConvert.group.js';
+import { GROUP_MIN_ITEMS_FOR_SUBGROUP, isExpiringTodayRow, isOverdueRow, runGroup, } from './todoSmartConvert.group.js';
 import { DEFAULT_TABID, FETCH_PAGE_SIZE, LIST_ENDPOINT_BY_CATEGORY, MAX_FETCH_LIMIT, MAX_FETCH_PAGES, guardListOnlyHost, readBoundedInt, readCategory, readFetchLimit, readPageSize, rowFromAny, } from './todoSmartConvert.core.js';
 const DEFAULT_REQUEST_SUMMARY_MAX = 50;
 export async function collectRawTodos(args, env) {
@@ -170,7 +170,7 @@ export async function collectRawTodos(args, env) {
         const fieldsById = new Map();
         if (focusText) {
             const targetRows = wfIdGroup
-                .filter((group) => !group.topPriority && focusAppliesToKind(focusText, detectBusinessKind(group.title)))
+                .filter((group) => !group.topPriority && activeRuleFor(group.title)?.aiGroup?.groupRule.aiContext === '流程详情')
                 .flatMap((group) => group.requestDatas ?? []);
             const targetIds = [...new Set(targetRows.map((row) => row.requestId).filter(Boolean))];
             if (targetIds.length > 0) {
@@ -189,26 +189,33 @@ export async function collectRawTodos(args, env) {
             }
         }
         // 给模型的紧凑视图使用组内序号，aiGroups 可用 seq 引用。
-        groupingBrief = wfIdGroup.map((group) => ({
-            groupId: group.id,
-            title: group.title,
-            count: group.count,
-            topPriority: group.topPriority,
-            items: (group.requestDatas ?? []).map((row, index) => ({
-                idx: index + 1,
-                requestId: row.requestId,
-                title: row.requestNameTitle ?? '',
-                // 客户问题支持类无侧重点时按这两个布尔分组（模型不用自己解析日期文案）
-                overdue: isOverdueRow(row),
-                expiringToday: isExpiringTodayRow(row),
-                ...(row.userOverTime ? { userOverTime: row.userOverTime } : {}),
-                ...(row.summary ? { summary: row.summary } : {}),
-                // `summaryCached:true` = 这条已有本地摘要（按 requestId__lastFeedBackDateTime 命中），
-                // 分组仍要做（聚类看标题），但**不要再给它写摘要**。
-                ...(cachedSummaryIds.has(row.requestId) ? { summaryCached: true } : {}),
-                ...(fieldsById.has(row.requestId) ? { fields: fieldsById.get(row.requestId) } : {}),
-            })),
-        }));
+        groupingBrief = wfIdGroup.map((group) => {
+            const groupRule = activeRuleFor(group.title)?.aiGroup?.groupRule;
+            // 分组口径随素材一起下发：模型生成 aiGroups 时必须遵循（只有 focus=false 的语义分组才有意义）
+            const groupingPrompt = groupRule && groupRule.focus === false
+                && typeof groupRule.groupingPrompt === 'string' ? groupRule.groupingPrompt.trim() : '';
+            return {
+                groupId: group.id,
+                title: group.title,
+                count: group.count,
+                topPriority: group.topPriority,
+                ...(groupingPrompt ? { groupingPrompt } : {}),
+                items: (group.requestDatas ?? []).map((row, index) => ({
+                    idx: index + 1,
+                    requestId: row.requestId,
+                    title: row.requestNameTitle ?? '',
+                    // 客户问题支持类无侧重点时按这两个布尔分组（模型不用自己解析日期文案）
+                    overdue: isOverdueRow(row),
+                    expiringToday: isExpiringTodayRow(row),
+                    ...(row.userOverTime ? { userOverTime: row.userOverTime } : {}),
+                    ...(row.summary ? { summary: row.summary } : {}),
+                    // `summaryCached:true` = 这条已有本地摘要（按 requestId__lastFeedBackDateTime 命中），
+                    // 分组仍要做（聚类看标题），但**不要再给它写摘要**。
+                    ...(cachedSummaryIds.has(row.requestId) ? { summaryCached: true } : {}),
+                    ...(fieldsById.has(row.requestId) ? { fields: fieldsById.get(row.requestId) } : {}),
+                })),
+            };
+        });
         // 用户侧重点原样回显：分组/排序都按「标题语义 + 侧重点」，模型照它决定子组与顺序。
         const groupingFocus = typeof args.groupFocus === 'string' ? args.groupFocus.trim() : '';
         groupInfo = {

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

@@ -331,6 +331,7 @@ export function rowFromAny(raw) {
         lastFeedBackDateTime: pick([
             'lastFeedBackDateTime', 'lastfeedbackdatetime', 'lastFeedbackDateTime', 'lastfeedbacktime', 'lastFeedbackTime',
         ]) ?? '',
+        ...(pick(['planFinishDatetime', 'planfinishdatetime']) ? { planFinishDatetime: pick(['planFinishDatetime', 'planfinishdatetime']) } : {}),
         summary: pick(['summary']),
         workflowName: pick(['workflowName', 'workflowname', 'workflowTypeName'], true),
         receivedTime: pick(['receivedTime', 'receivedtime', 'receivedatetime', 'operatedatetime', 'stayStartAt']),

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

@@ -196,6 +196,7 @@ export function toRequestData(row) {
         creater: row.creater,
         createrName: row.createrName,
         lastFeedBackDateTime: row.lastFeedBackDateTime,
+        ...(row.planFinishDatetime ? { planFinishDatetime: row.planFinishDatetime } : {}),
         summary: row.summary ?? '',
     };
 }

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

@@ -1,3 +1,4 @@
+import { activeRuleFor } from './aigroupRules.js';
 import { workflowValidationError } from '../../errors.js';
 import { asRecord, readBoundedInt } from './todoSmartConvert.core.js';
 import { detectBusinessKind, isDeterministicGroupKind, GROUP_SUMMARY_TAIL_TEXT, } from './businessRules.js';
@@ -191,7 +192,7 @@ export async function runGroupSummaryContext(args, env) {
     }
     const deterministicGroups = groups
         .filter((group) => !group.topPriority
-        && isDeterministicGroupKind(detectBusinessKind(group.title)))
+        && activeRuleFor(group.title)?.aiGroup?.groupSummary.needAI === false)
         .reduce((sum, group) => sum + groupItemsOf(group).length, 0);
     return {
         data: {

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

@@ -25,7 +25,7 @@ const inputSchema = schemaOf({
     },
     aiGroups: {
         type: 'array',
-        description: 'smartGroup 的二次分组计划。每项必须提供 groupId、title，以及 requestIds 与 seq 二选一。',
+        description: 'smartGroup 的二次分组计划。每项必须提供 groupId、title、requestIds。',
         items: {
             type: 'object',
             additionalProperties: false,
@@ -33,10 +33,8 @@ const inputSchema = schemaOf({
                 groupId: { type: 'string' },
                 title: { type: 'string' },
                 requestIds: { type: 'array', minItems: 1, items: { type: 'string' } },
-                seq: { type: 'array', minItems: 1, items: { type: 'integer', minimum: 1 } },
             },
-            required: ['groupId', 'title'],
-            oneOf: [{ required: ['requestIds'] }, { required: ['seq'] }],
+            required: ['groupId', 'title', 'requestIds'],
         },
     },
     aiSummaries: {

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

@@ -1,8 +1,9 @@
 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 { renderGroupSummaryTemplate, } 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 { PRIORITY_GROUP_ID, PRIORITY_GROUP_TITLE, runGroup, GROUP_MIN_ITEMS_FOR_SUBGROUP, } from './todoSmartConvert.group.js';
 import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
+import { activeRuleFor, evaluateFocusKeywords, primeRules } from './aigroupRules.js';
 import { openSummaryCache } from './summaryCache.js';
 const DEFAULT_REQUEST_SUMMARY_MAX = 50;
 /** 把一批条目包成「单独展示」项（优先组、以及普通组里没同类可合并的条目都用它）。 */
@@ -38,9 +39,9 @@ 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', 'seq'].includes(key));
+        const unknownKeys = Object.keys(record).filter((key) => !['groupId', 'title', 'requestIds'].includes(key));
         if (unknownKeys.length > 0) {
-            throw workflowValidationError('ai_groups_invalid', `${label} 不接受字段：${unknownKeys.join(', ')}；只支持 groupId / title / requestIds / seq`, { retryAllowed: false, details: { unknownKeys } });
+            throw workflowValidationError('ai_groups_invalid', `${label} 不接受字段：${unknownKeys.join(', ')}；只支持 groupId / title / requestIds`, { retryAllowed: false, details: { unknownKeys } });
         }
         const groupId = typeof record.groupId === 'string' ? record.groupId.trim() : '';
         if (!groupId) {
@@ -51,25 +52,11 @@ export function readAiGroups(value) {
             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);
-            }
+        if (!hasIds) {
+            throw workflowValidationError('ai_groups_invalid', `${label} 必须给 requestIds（非空的 requestId 字符串数组）`, { retryAllowed: false });
         }
         const ids = [];
-        for (const item of (hasIds ? record.requestIds : [])) {
+        for (const item of 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 });
@@ -77,7 +64,7 @@ export function readAiGroups(value) {
             ids.push(id);
         }
         const bucket = map.get(groupId) ?? [];
-        bucket.push({ groupId, title, requestIds: [...new Set(ids)], seq: [...new Set(seqNumbers)] });
+        bucket.push({ groupId, title, requestIds: [...new Set(ids)] });
         map.set(groupId, bucket);
     });
     return map;
@@ -109,42 +96,32 @@ function rowMetricsOf(row, metrics) {
  * 金额算不出来时（表单没有金额字段、标题里也没有 `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 });
+/**
+ * 取一条流程在某个「指标名」上的值（规则 `focusKeyword` 求值用）。
+ *
+ * - `sysArg=true`：指标名就是 `getTodoListData` 返回的属性名（如 `planFinishDatetime`）；
+ * - `sysArg=false`：先映射到结构化指标（金额 / 天数 / 假别），再退到「详情字段名包含指标名」；
+ *   都取不到返回 `undefined` —— 调用方按「不命中 + warning」处理（2026-10-28 用户定：
+ *   正则提不到就平铺并告警，不做 AI 兜底）。
+ */
+function metricValueOf(row, metric, sysArg, facts, metrics) {
+    if (sysArg) {
+        const key = Object.keys(row).find((item) => item.toLowerCase() === metric.toLowerCase());
+        return key ? row[key] : undefined;
     }
-    if (kind === 'leave') {
-        const items = rows.map((row) => rowMetricsOf(row, metrics));
-        return formatLeaveGroupSummary({
-            count: rows.length,
-            leaveTypes: items.map((item) => item.leaveType),
-            creators,
-        });
+    const rowMetrics = metrics?.get(row.requestId);
+    if (rowMetrics) {
+        if (/金额|费用|价|合计/u.test(metric) && typeof rowMetrics.amount === 'number')
+            return rowMetrics.amount;
+        if (/天数|时长/u.test(metric) && typeof rowMetrics.leaveDays === 'number')
+            return rowMetrics.leaveDays;
+        if (/假别|假种|假期/u.test(metric) && typeof rowMetrics.leaveType === 'string')
+            return rowMetrics.leaveType;
     }
-    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;
+    const fact = facts?.get(row.requestId);
+    const field = (fact?.fields ?? []).find((item) => String(item.fieldName ?? '').includes(metric));
+    const value = field?.value;
+    return value === undefined || String(value).trim() === '' ? undefined : value;
 }
 /**
  * 最终结构里的 `totalCount`：**去重后的待办条数**（= collect 阶段取到的全部条数）。
@@ -229,6 +206,8 @@ export async function runSmartGroup(args, env, options = {}) {
     // 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');
     }
@@ -243,7 +222,7 @@ export async function runSmartGroup(args, env, options = {}) {
                 topPriority: true,
                 title: group.title,
                 count: group.count,
-                // 只有优先组默认展开，其余分组一律收缩。
+                // 大分组（含优先组）默认展开；只有汇总项（ai二次分组）收缩。
                 defaultExpanded: true,
                 displayItems: requestItemsOf(group.requestDatas),
             };
@@ -256,126 +235,79 @@ export async function runSmartGroup(args, env, options = {}) {
          * 注意：不存在 `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,
+            defaultExpanded: true,
             displayItems: requestItemsOf(group.requestDatas),
         });
-        // D0 满意度类：不做 ai二次分组，也不与 AI 交互。
-        if (kind === 'satisfaction') {
+        const rawPlans = plans?.get(group.id) ?? [];
+        /** 本组生效规则（`aigroup` JSON）：没有 `aiGroup` ⇒ 不做二次分组。 */
+        const rule = activeRuleFor(group.title);
+        if (!rule?.aiGroup) {
             if (rawPlans.length > 0)
-                warnings.push(`「${group.title}」满意度类不做 ai二次分组，已忽略 aiGroups`);
-            warnings.push(`「${group.title}」属于满意度类，全部平铺单条；summary 由标题兜底（不调 AI）`);
+                warnings.push(`「${group.title}」未配置 aiGroup，已忽略 aiGroups`);
+            if (!rule?.needSummary)
+                warnings.push(`「${group.title}」不需要 AI 摘要，summary 用标题兜底`);
+            warnings.push(`「${group.title}」未配置 ai二次分组，${group.requestDatas.length} 条平铺`);
             return flatReturn();
         }
-        // D1 硬门槛：组内 <3 条一律平铺（即使给了 aiGroups 也忽略，不与 AI 交互）。
+        const groupRule = rule.aiGroup.groupRule;
+        const focusMode = groupRule.focus === true;
+        const groupPlans = rawPlans;
+        // 全局硬门槛：组内 <3 条一律平铺（规则/计划都覆盖不了）。
         if (group.requestDatas.length < GROUP_MIN_ITEMS_FOR_SUBGROUP) {
             if (rawPlans.length > 0)
-                warnings.push(`「${group.title}」不足 3 条（硬门槛），忽略 aiGroups 并平铺`);
+                warnings.push(`「${group.title}」不足 ${GROUP_MIN_ITEMS_FOR_SUBGROUP} 条（硬门槛），忽略 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}`, {
+        /** `focus:false` 必须给计划（没有「平铺」这个第三态）；`focus:true` 没计划时按 focusKeyword 确定性成组。 */
+        if (!focusMode && groupPlans.length === 0) {
+            const groupingPrompt = typeof groupRule.groupingPrompt === 'string' ? groupRule.groupingPrompt.trim() : '';
+            throw workflowValidationError('ai_groups_required', `「${group.title}」按规则要求做 AI 二次分组（focus=false，上下文：${groupRule.aiContext ?? '流程标题'}），`
+                + `必须给本组 aiGroups；可用 groupId：${group.id}，requestIds 取本组 ${group.requestDatas.length} 条`
+                + (groupingPrompt ? `。分组口径（groupingPrompt）：${groupingPrompt}` : ''), {
                 retryAllowed: true,
-                details: { groupId: group.id, count: group.requestDatas.length, groupFocus: groupHasFocus ? groupFocus : '' },
+                details: {
+                    groupId: group.id,
+                    count: group.requestDatas.length,
+                    aiContext: groupRule.aiContext ?? '',
+                    ...(groupingPrompt ? { groupingPrompt } : {}),
+                },
             });
         }
         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二次分组、按单条平铺`);
-                }
+            // 规则 focus=true 且没有计划：按 focusKeyword 确定性成一组（与业务类型无关）。
+            const conditions = groupRule.focusKeyword ?? [];
+            const sysArg = groupRule.sysArg === true;
+            const hit = [];
+            const missing = new Set();
+            for (const row of group.requestDatas) {
+                const resolve = (metric) => {
+                    const value = metricValueOf(row, metric, sysArg, facts, metrics);
+                    if (value === undefined)
+                        missing.add(metric);
+                    return value;
+                };
+                if (conditions.length > 0 && evaluateFocusKeywords(conditions, resolve))
+                    hit.push(row);
+                else
+                    singles.push(row);
             }
-            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 未命中），全部平铺`);
-                }
+            const conditionText = conditions.map((condition) => condition.join(' ')).join(' 且 ');
+            const title = groupRule.groupTitle?.trim() || conditionText || '汇总';
+            if (hit.length > 0) {
+                subGroups.push({ title, requestDatas: hit });
+                warnings.push(`「${group.title}」按规则「${title}」命中 ${hit.length} 条（${conditionText}），其余 ${group.requestDatas.length - hit.length} 条平铺`);
             }
             else {
-                singles.push(...group.requestDatas);
-                warnings.push(`「${group.title}」默认不做 ai二次分组，${group.requestDatas.length} 条平铺`);
+                warnings.push(`「${group.title}」规则「${title}」命中 0 条${conditionText ? `（${conditionText}）` : ''}，全部平铺`);
+            }
+            if (missing.size > 0) {
+                warnings.push(`「${group.title}」指标取不到：${[...missing].join('、')}，相关条目按单条平铺；请检查规则里的指标名`);
             }
         }
         else {
@@ -385,22 +317,12 @@ export async function runSmartGroup(args, env, options = {}) {
              * 模型若拿它当子组名，CLI 必须逐条核阈值——否则 2000 元的报销会出现在「100元以内」里。
              * 超阈值的条目剔出、转单条展示（一条都不丢），并点名。
              */
-            const reservedTitle = kind === 'leave'
-                ? LEAVE_GROUP_TITLE
-                : kind === 'finance' ? FINANCE_GROUP_TITLE : '';
+            /** 保留标题 = 规则里的 groupTitle：计划若用它当子组名，必须逐条核 focusKeyword。 */
+            const reservedTitle = groupRule.groupTitle ?? '';
             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;
-                    });
+                const planRequestIds = plan.requestIds;
                 for (const requestId of planRequestIds) {
                     const data = byRequestId.get(requestId);
                     if (!data) {
@@ -417,13 +339,11 @@ export async function runSmartGroup(args, env, options = {}) {
                 if (reservedTitle && plan.title === reservedTitle) {
                     const kept = [];
                     const dropped = [];
+                    const conditions = groupRule.focusKeyword ?? [];
+                    const sysArg = groupRule.sysArg === true;
                     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);
+                        const resolve = (metric) => metricValueOf(row, metric, sysArg, facts, metrics);
+                        (conditions.length > 0 && evaluateFocusKeywords(conditions, resolve) ? kept : dropped).push(row);
                     }
                     if (dropped.length > 0) {
                         droppedByThreshold.push(...dropped);
@@ -454,10 +374,50 @@ export async function runSmartGroup(args, env, options = {}) {
                 singles.push(...uncovered);
                 warnings.push(`「${group.title}」有 ${uncovered.length} 条未被 AI 分组，按单条平铺（不造 other 子组）`);
             }
+            /**
+             * `focus=true` 的组**最多只留一个汇总项**（2026-10-28 用户定：侧重点产出多个子组时，
+             * 只保留涉及数据最多的那个，其余条目平铺——多组会造成重复展示、批量处理口径有争议）。
+             */
+            if (focusMode && subGroups.length > 1) {
+                const sorted = [...subGroups].sort((a, b) => b.requestDatas.length - a.requestDatas.length);
+                const [keep] = sorted;
+                const dropped = sorted.slice(1);
+                const droppedCount = dropped.reduce((sum, sub) => sum + sub.requestDatas.length, 0);
+                for (const sub of dropped)
+                    singles.push(...sub.requestDatas);
+                subGroups.length = 0;
+                subGroups.push(keep);
+                warnings.push(`「${group.title}」侧重点产出 ${sorted.length} 个子组，按规则只保留条数最多的「${keep.title}」`
+                    + `（${keep.requestDatas.length} 条），其余 ${droppedCount} 条改单条平铺`);
+            }
         }
+        /** 组摘要：规则 `needAI:false` 时用 JSON `template` 渲染，否则留空交 AI。 */
+        const renderSubGroupSummary = (sub) => {
+            const groupSummary = rule.aiGroup?.groupSummary;
+            if (!groupSummary || groupSummary.needAI || !groupSummary.template)
+                return '';
+            if (groupRule.groupTitle && sub.title !== groupRule.groupTitle)
+                return '';
+            const rows = sub.requestDatas;
+            const items = rows.map((row) => rowMetricsOf(row, metrics));
+            const amounts = items
+                .map((item) => item.amount)
+                .filter((value) => typeof value === 'number' && value > 0);
+            if (groupSummary.template.includes('{{min}}') && amounts.length === 0)
+                return '';
+            return renderGroupSummaryTemplate({
+                template: groupSummary.template,
+                tail: groupSummary.tail,
+                count: rows.length,
+                restCount: singles.length,
+                categories: items.map((item) => item.leaveType ?? item.feeCategory),
+                amounts,
+                creators: rows.map((row) => row.createrName),
+            });
+        };
         // 条数降序；sort 稳定，同条数保持 AI 给出的先后顺序。
         // 有侧重点时沿用模型顺序；没有侧重点时按条数降序。
-        if (!groupHasFocus)
+        if (!focusMode)
             subGroups.sort((a, b) => b.requestDatas.length - a.requestDatas.length);
         const groupItems = subGroups.map((sub, index) => ({
             // 键顺序照新目标结构：type → id → title → count → summary → defaultExpanded → requestDatas
@@ -466,11 +426,7 @@ export async function runSmartGroup(args, env, options = {}) {
             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) ?? '')
-                : '',
+            summary: renderSubGroupSummary(sub),
             // 汇总项自身默认收缩（与大分组的展开状态互相独立）
             defaultExpanded: false,
             requestDatas: sub.requestDatas,
@@ -480,7 +436,8 @@ export async function runSmartGroup(args, env, options = {}) {
             topPriority: false,
             title: group.title,
             count: group.count,
-            defaultExpanded: false,
+            // 大分组默认展开（与汇总项自身的收缩状态互相独立）
+            defaultExpanded: true,
             // 汇总项在前、单独条目在后。
             displayItems: [...groupItems, ...requestItemsOf(singles)],
         };