weaver-work-cli 0.1.32 → 0.1.36

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)],
         };

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

@@ -1,10 +1,15 @@
+import { activeRuleFor } from './aigroupRules.js';
 import { workflowValidationError } from '../../errors.js';
 import { asRecord, readBoundedInt } from './todoSmartConvert.core.js';
 import { orderGroupsByIntent, readGroupOrder } from './todoSmartConvert.group.js';
-import { detectBusinessKind, needsRequestSummary, usesTitleSummary } from './businessRules.js';
+import { detectBusinessKind, needsRequestSummary } from './businessRules.js';
 import { openSummaryCache } from './summaryCache.js';
 import { loadDetailContextProvider, stampsOfRows } from './todoSmartConvert.detail.js';
 import { requestItemsOf, rowsOfGroup, runSmartGroup, totalTodoCount, } from './todoSmartConvert.smartGroup.js';
+/** 该组是否需要 AI 生成单条摘要（规则 needSummary 决定，默认需要）。 */
+function needAiSummary(workflowName) {
+    return activeRuleFor(workflowName)?.needSummary ?? true;
+}
 const DEFAULT_MAX_CHARS_PER_BATCH = 24_000;
 const DEFAULT_MAX_ITEMS_PER_BATCH = 100;
 const DEFAULT_REQUEST_SUMMARY_MAX = 50;
@@ -101,7 +106,7 @@ export function validateFinalGroups(value) {
         const count = displayItems.reduce((sum, item) => sum + (item.type === 'group' ? item.requestDatas.length : 1), 0);
         return topPriority
             ? { id, topPriority: true, title, count, defaultExpanded: true, displayItems }
-            : { id, topPriority: false, title, count, defaultExpanded: false, displayItems };
+            : { id, topPriority: false, title, count, defaultExpanded: true, displayItems };
     });
 }
 /**
@@ -129,7 +134,7 @@ export function collectSummaryUnits(groups) {
     const units = [];
     for (const group of groups) {
         if (group.topPriority) {
-            if (!needsRequestSummary(detectBusinessKind(group.title)))
+            if (!needAiSummary(group.title))
                 continue;
             units.push({
                 groupId: group.id,
@@ -185,7 +190,7 @@ export async function runSummaryContext(args, env, prefetched) {
     const groups = await readFinalGroups(args, env);
     const units = collectSummaryUnits(groups);
     const skippedSatisfaction = groups
-        .filter((group) => usesTitleSummary(detectBusinessKind(group.title)))
+        .filter((group) => !needAiSummary(group.title))
         .reduce((sum, group) => sum + rowsOfGroup(group).length, 0);
     // 优先组是叠加视图 ⇒ 同一条待办会在两个位置各出现一次，统计口径必须去重。
     const requestIds = [...new Set(units.flatMap((unit) => unit.rows.map((row) => row.requestId)))].filter(Boolean);
@@ -394,7 +399,7 @@ export async function runSummary(args, env) {
     // 满意度类不走 AI、也不读缓存：直接用标题当摘要，保证 `summary` 不为空。
     let titleSummary = 0;
     for (const group of groups) {
-        if (usesTitleSummary(detectBusinessKind(group.title))) {
+        if (!needAiSummary(group.title)) {
             for (const row of rowsOfGroup(group)) {
                 if ((row.summary ?? '').trim())
                     continue;
@@ -470,7 +475,7 @@ export async function runSummary(args, env) {
         }
     };
     for (const group of groups) {
-        if (!needsRequestSummary(detectBusinessKind(group.title)))
+        if (!needAiSummary(group.title))
             continue;
         if (group.topPriority) {
             applyAll(rowsOfGroup(group));
@@ -499,7 +504,7 @@ export async function runSummary(args, env) {
         warnings.push(`有 ${prefilledKept} 条沿用本地摘要缓存（未重新生成）`);
     }
     const titleSummaryCount = groups
-        .filter((group) => usesTitleSummary(detectBusinessKind(group.title)))
+        .filter((group) => !needAiSummary(group.title))
         .reduce((sum, group) => sum + rowsOfGroup(group).length, 0);
     if (titleSummaryCount > 0) {
         warnings.push(`有 ${titleSummaryCount} 条满意度类待办不调用 AI，summary 直接使用条目标题（保证非空）`);

package/dist/shortcuts/workflow/operations.js

@@ -59,6 +59,12 @@ function clarificationEnvelope(error, operation) {
         ? details.clarificationQuestion
         : error.message;
     const reason = typeof details.clarificationReason === 'string' ? details.clarificationReason : '';
+    // 必填入参缺失（当前只有 `workflow_required` 一档）时，把「缺了哪个键、该按什么形态补」一并下发：
+    // 模型原先只能看到「请提供完整名称」，无法区分「用户没说要发起什么」与「我键名写错了」。
+    const missingInput = Array.isArray(details.missingInput) ? details.missingInput.map(String) : [];
+    const requiredInput = details.requiredInput && typeof details.requiredInput === 'object'
+        ? details.requiredInput
+        : null;
     return workflowSuccess(operation, {
         type: 'workflowClarification',
         status: 'NEEDS_CLARIFICATION',
@@ -66,6 +72,8 @@ function clarificationEnvelope(error, operation) {
         clarificationKeyword: details.clarificationKeyword ?? null,
         clarificationQuestion: question,
         ...(reason ? { clarificationReason: reason } : {}),
+        ...(missingInput.length ? { missingInput } : {}),
+        ...(missingInput.length && requiredInput ? { requiredInput } : {}),
         candidates,
         candidateCount: candidates.length,
         note: clarificationNote(reason, candidates.length),
@@ -80,10 +88,24 @@ function clarificationEnvelope(error, operation) {
  * - `no_create_right` —— 流程**存在**但当前账号没有发起权限，**绝不能**说成"不存在"
  *   （那正是把"没权限"伪装成"没有这条流程"，与项目纪律相反）。
  *
- * 无 `reason` 时（名称解析 0 / 多命中）保持原文案不变。
+ * 2026-10-30 新增一档：
+ * - `workflow_required` —— **必填入参没给**（缺键/空数组/空字符串）。它不是「名称匹配不到」，
+ *   而是调用方少传了入参；文案必须让模型先认账、再问用户要流程名，而不是让用户去"核对名称"。
+ *
+ * 无 `reason` 时（名称解析 0 / 多命中 / 只给了填充词）保持原文案不变。
  */
 function clarificationNote(reason, candidateCount) {
     const base = '这不是失败，也**不代表查询已执行**：本次查询已停止，没有返回任何流程数据。';
+    // ★ 2026-10-30：`workflow_required` = **必填入参没给**，与「名称匹配不到」性质完全不同。
+    // 这里要模型先认账（少传了入参），而不是去问用户「是不是名字打错了」。
+    if (reason === 'workflow_required') {
+        return '本次命令**没有拿到必填入参 `workflow`**（没写这个键、空数组、空字符串都算没给）——'
+            + '命令停在了查询之前：**没有发起任何流程**，也没有去查可发起列表，'
+            + '这既不是执行失败，也不代表「没有匹配的流程」。'
+            + '请先向用户确认要发起哪个流程（**必须问，不要自己猜，也不要拿相似的名字代替**），'
+            + '再按 `requiredInput.workflow` 给出的形态把入参补上、重发同一条命令。'
+            + '注意 `--input` 接收的是**文件路径**（`-` 表示标准输入），内联 JSON 要用 `--input-json`。';
+    }
     if (reason === 'workflow_not_exist') {
         return base + '请如实告知用户：该工作流不存在（可能已删除或被停用），'
             + '请用户改用该流程的完整名称（或其它可用于检索的关键词）重新指定——**不要向用户索取 ID**。'

package/docs/e10-auth.md

@@ -69,7 +69,7 @@ E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置
 
 `auth xiaoe` 会先打印不含凭证的 preflight 摘要，给出 `authMode=xiaoe`、`credentialSourceDetected`、`attempted`、各凭据源检测结果和目标 `baseUrl`。进入脚本分支时会打印 `Trying XiaoE token script credential...`；进入内置 Node 会话分支时会打印 `Trying built-in XiaoE client session credential...`。成功结果和后续 `auth status` 会显示 `credentialSourceStep`、`credentialSourceType`、`credentialSourceLabel`。
 
-业务命令不会在缺少本地会话时主动建立 XiaoE 登录态，首次使用仍需显式执行 `auth xiaoe`。已有会话被 E10 接口明确拒绝为失效时，公共请求运行时会静默换票并重放原请求一次；不会打印中间登录步骤，不会自动打开浏览器，也不会对流式请求、网络错误、`partial` / `write_uncertain` 做重放。桌面客户端需要 XiaoE 专属业务行为时，Agent 必须显式传全局参数，例如 `weaver-work-cli --runtime-agent xiaoe workflow ...`；网页端由原有环境变量规则自动识别，不要求补这个参数。`--runtime-agent` 只控制运行时行为，不携带也不选择凭据。WorkBuddy、Codex 及其他智能体使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
+业务命令不会在缺少本地会话时主动建立 XiaoE 登录态，首次使用仍需显式执行 `auth xiaoe`。已有 XiaoE 会话被 E10 接口明确拒绝为失效时，公共请求运行时会根据持久化会话的 `agentType` / `loginSource` 静默换票并重放原请求一次；这条路径不依赖 shared Skill、Agent、`XIAOE_*` 或 `--runtime-agent xiaoe`。它不会打印中间登录步骤，不会自动打开浏览器，也不会对流式请求、网络错误、`partial` / `write_uncertain` 做重放。`--runtime-agent xiaoe` 仅用于其他 XiaoE 专属业务行为，不携带也不选择凭据。WorkBuddy、Codex 及其他智能体首次认证使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
 
 无法使用浏览器回调时，可以用 `auth set` 直接写入浏览器中复制到的
 `ETEAMSID`。命令会调用 `teamsCheck` 解析当前用户、租户和组织信息，并写入

package/docs/ehr.md

@@ -56,7 +56,7 @@ weaver-work-cli --json ehr run <operation> --input -
 
 CLI 原样透传整个响应对象，不做重命名；取用方按上表判断。
 
-**每页条数**：由服务端按接口独立配置，**`pageSize` 传参无效**（实测）：通讯录 100、出勤表格类 20、`worktime`/`leave.report` 10、hr 报表 20、薪酬 `bill.list`/`employee.list` 20、`empchange.list` 100。全量数据一律递增 `current` 翻页。
+**每页条数**：由服务端按接口独立配置，**`pageSize` 传参无效**（实测）：通讯录 100、出勤表格类 20、`worktime`/`leave.report` 10、hr 报表 20、薪酬 `bill.list` 20、`empchange.list` 100。全量数据一律递增 `current` 翻页。
 
 **成功响应的 `data` 恒存在**：业务数据为 `undefined` 时（如社保福利、调薪记录为空）统一补为 `null`，避免 `JSON.stringify` 省略该键导致调用方需判断键是否存在。
 

package/docs/fna.md

@@ -21,7 +21,7 @@
 | `fna.expense.reimbursed.sum` | read | POST `expense/center/getSumReimbursedAmountByAi`；body 可空 |
 | `fna.expense.loan.sum` | read | POST `expense/center/getSumLoanAmountByAi`；只认数字 ID；空 data 自动重试 2 次；已知仅统计首条记录缺陷 |
 | `fna.expense.prepay.writeoff.sum` | read | POST `expense/center/selectPrepayWriteOffAmountBySkill`；body 可空 |
-| `fna.expense.chart` | read | GET `getExpenseChart`（`/api/secondev/fna/`）；`userInput` 必填 ≤500 字；`maxRows` 本地截断 1-5000，默认 200；超时 180s；返回 `kind=rows/empty/clarify/blocked/unexpected` |
+| `fna.expense.chart` | read | GET `getExpenseChart`（`/api/secondev/fna/`）；`userInput` 必填 ≤500 字；`maxRows` 本地截断 1-5000，默认 200；超时 180s；返回 `kind=rows/empty/clarify/blocked/unexpected`；无权限文案额外返回 `meta.permissionDenied=true` |
 | `fna.loan.main.page` | read | POST `loanManagementMenu/mainPage` |
 | `fna.loan.main.list` | read | POST `loanManagementMenu/mainPageList`；`current`/`pageSize`/`menuCode`/`permissionSetCode` 必填 |
 | `fna.loan.remind.repay.prepare` | write | 校验 displayData 行并预览，不发送 |
@@ -65,6 +65,7 @@ weaver-work-cli --json fna run fna.invoice.writeoff.list --input-json '{"current
 - `menuCode`/`permissionSetCode` 环境相关，示例值需与环境核对。
 - 超 2^53 的 requestId 无法用 JS 数字精确表达，保留字符串并提示人工核验（真实环境 ID 一般在安全整数内，已按数字发送）。
 - `fna.expense.chart`：`code` 恒为 200，必须按 `data` 类型/`kind` 判成败；追问与安全拦截都是字符串 `data`，`meta.messageKindInferred=true` 表示归类为 CLI 推断。实测真实查询 3.3~66.6s，CLI 超时设 180s，禁止自动重试（每次都会消耗模型额度）。不做当前人强制过滤，结果可能是全租户范围；`userInput` 为商品化输入，个人口径必须改用 `fna.expense.reimbursed.sum`。二开包未安装时该 operation 会 404/500，需与其它 `fna.*` 正常但本 operation 失败区分。
+- `fna.expense.chart` 的权限语义：文案含「权限 / 越权」时 CLI 归类为 `clarify` 并置 `meta.permissionDenied=true`（纯权限提示不带「不明确」关键词也照样识别，避免落进 `unexpected` 被误判）。这是**终止信号**，不是换问法信号：Agent 必须直接告知权限边界，禁止改调 `fna.expense.reimbursed.sum`、`fna.budget.*`、借款 / 核销等接口按部门 / 人员 / 金额拼装同一份报表，也禁止自写 SQL 绕过。
 
 ## 验证