weaver-work-cli 0.1.40 → 0.1.44

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' },
@@ -140,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 });
             }
@@ -167,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);
@@ -201,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,
+    };
+}

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

@@ -178,7 +178,10 @@ export function collectSummaryUnits(groups) {
             continue;
         }
         const kind = detectBusinessKind(group.title);
-        if (!needsRequestSummary(kind))
+        // 规则 `needSummary:false`（default.json）⇒ 整组不进 AI 批次（标题兜底，见 runSummary）。
+        // 2026-11-03 用户定：此前这里只认硬编码业务类型（仅满意度被排除），导致规则里配了 false 的组
+        // 仍然生成素材、把「待写摘要」虚报成几百条。
+        if (!needAiSummary(group.title) || !needsRequestSummary(kind))
             continue;
         for (const item of group.displayItems) {
             if (item.type === 'group') {
@@ -244,12 +247,14 @@ export async function runSummaryContext(args, env, prefetched) {
      * 先建 requestId → 工作流组名 的映射，优先组的行查这张表。
      */
     const workflowTitleByRequest = new Map();
-    for (const unit of units) {
-        if (unit.groupId === 'priority')
+    // 从**全部工作流组**建映射（不能用 units：`needSummary:false` 的组不产 unit，但它们在优先组里
+    // 仍有副本，缺了映射就会被当成「建议优先处理的流程」⇒ 落 `*` 兜底 ⇒ 误判成需要 AI）。
+    for (const group of groups) {
+        if (group.topPriority)
             continue;
-        for (const row of unit.rows) {
+        for (const row of rowsOfGroup(group)) {
             if (row.requestId && !workflowTitleByRequest.has(row.requestId)) {
-                workflowTitleByRequest.set(row.requestId, unit.groupTitle);
+                workflowTitleByRequest.set(row.requestId, group.title);
             }
         }
     }
@@ -259,6 +264,10 @@ export async function runSummaryContext(args, env, prefetched) {
     for (const unit of units) {
         for (const row of unit.rows) {
             const name = ruleNameForRow(unit, row);
+            // 规则 `needSummary:false` ⇒ 不取详情、不进批次，摘要由 `runSummary` 用标题兜底
+            // （2026-11-03 用户定：优先组副本此前按组名判定，把这批条目也算成了待写）。
+            if (!needAiSummary(name))
+                continue;
             const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, explicitMaxCharsFor(args, name), promptTagOf(requestPromptFor(name)), materialTagOfRow(row.requestId, row.lastFeedBackDateTime));
             if (cached) {
                 row.summary = cached;
@@ -321,6 +330,16 @@ export async function runSummaryContext(args, env, prefetched) {
             // 摘要缓存已命中（上一步预填）⇒ 不再喂 AI
             if (prefilledIds.has(row.requestId))
                 continue;
+            // 规则 `needSummary:false` ⇒ 标题兜底、不进批次（优先组副本按**原工作流**口径判定）。
+            // 2026-11-03：此前只在「详情为空」时才复制标题，规则豁免完全没接，规则 false 的条目照样进批次。
+            if (!needAiSummary(ruleNameForRow(unit, row))) {
+                if (!(row.summary ?? '').trim()) {
+                    row.summary = row.requestNameTitle ?? '';
+                    if ((row.summary ?? '').trim())
+                        titleCopied += 1;
+                }
+                continue;
+            }
             const { context, contextAvailable: available } = provider.get(row.requestId);
             if (!available) {
                 // ★ 详情为空 ⇒ 不喂 AI，summary 直接复制标题（确定性操作，不走模型）。
@@ -487,21 +506,27 @@ export async function runSummary(args, env) {
         }
     }
     const ruleNameForGroup = (group, row) => group.topPriority ? (wfTitleByRequest.get(row?.requestId ?? '') ?? group.title) : group.title;
+    /**
+     * 逐条按**原工作流口径**判定（2026-11-03 用户定：优先组副本空摘要修复）。
+     *
+     * 旧实现按「组」判定，且优先组被整组跳过标题兜底——但优先组的组名匹配不到规则（会落到 `*` 兜底，
+     * `needSummary` 被当成 true），于是 `needSummary:false` 的条目（如内部留言、安全问题工单）
+     * 在优先组里的副本既没走标题兜底、又没走 AI 批次，summary 恒为空 ⇒ 导出闸门拦截。
+     * 现在改为逐条解析口径：`needSummary:false` ⇒ 标题兜底（与普通组副本一致），否则读摘要缓存。
+     */
     for (const group of groups) {
-        if (!needAiSummary(group.title)) {
-            for (const row of rowsOfGroup(group)) {
-                if ((row.summary ?? '').trim())
-                    continue;
+        for (const row of rowsOfGroup(group)) {
+            if ((row.summary ?? '').trim())
+                continue;
+            const name = ruleNameForGroup(group, row);
+            if (!needAiSummary(name)) {
                 row.summary = row.requestNameTitle ?? '';
                 if ((row.summary ?? '').trim())
                     titleSummary += 1;
+                continue;
             }
-            continue;
-        }
-        for (const row of rowsOfGroup(group)) {
-            if (!row?.requestId || (row.summary ?? '').trim())
+            if (!row?.requestId)
                 continue;
-            const name = ruleNameForGroup(group, row);
             const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, explicitMaxCharsFor(args, name), promptTagOf(requestPromptFor(name)), materialTagOfRow(row.requestId, row.lastFeedBackDateTime));
             if (cached) {
                 row.summary = cached;

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

@@ -1,3 +1,4 @@
+import { CONTINUATION_TTL_SECONDS } from '../../../core/continuation-ttl.js';
 import { createHash } from 'node:crypto';
 import { WorkflowCliError, workflowConfirmationError, workflowPartialError, workflowValidationError, } from '../errors.js';
 import { continuationReplayError } from '../continuation.js';
@@ -17,7 +18,6 @@ import { findIndexedItem, loadSearchIndex, } from '../state.js';
 // 「确定性幂等键 + 有界保护窗口」的一次性闸门承担（见 batchIdempotencyKey / claimBatchWrite）。
 // 写请求遇网络中断/超时（结果未知）一律抛 workflowPartialError，禁止自动重试。
 // ===========================================================================
-const CONTINUATION_TTL_SECONDS = 600;
 const BATCH_SIZE_DEFAULT = 100;
 const READ_REMARK_VALUES = new Set(['60', '61', '70', '71', '80', '81']);
 // 共享对象类型 → addRequestShare2 的 shareType

package/docs/_catalog.md

@@ -13,6 +13,7 @@
 | 齐业成费控中心（预算/费用中心/报销报表 AI 问答/借款管理/发票核销）、fna operation、提醒还款与催票 prepare/apply | `docs/fna.md` |
 | 文书定档案管理（全宗/检索/借阅车/借阅单/发起借阅/预归档上传）、wenshuding operation | `docs/wenshuding.md` |
 | 计划报告管理（报告查询/新建/修改/发布/撤回/提交提醒/评论）、plan operation、写操作 prepare/apply | `docs/plan.md` |
+| 客户参观接待（面板/行程单与内部方案/填单页预填）、reception operation、零写请求 | `docs/reception.md` |
 | OKR 目标管理（目标查询/详情、关键成果、目标对齐、评论）、okr operation、标准版与 ebuilder 双链路、写操作 prepare/apply | `docs/okr.md` |
 | eBuilder 表单（菜单定位、List/NList、字段/浏览、OpenAPI 与自定义接口）、ebuilder-form operation、写操作 prepare/apply | `docs/ebuilder-form.md` |
 | E10 ESB 中心自定义触发动作流（入参模板查询 / prepare-apply 触发）、esb operation | `docs/esb.md` |
@@ -30,6 +31,8 @@
 | Agent 调用齐业成费控 CLI 的具体 reference | `skills/weaver-e10-qiyecheng/references/` |
 | Agent 调用计划报告 CLI 的入口路由 | `skills/weaver-e10-plan/SKILL.md` |
 | Agent 调用计划报告 CLI 的具体 reference | `skills/weaver-e10-plan/references/` |
+| Agent 调用客户参观接待 CLI 的入口路由 | `skills/weaver-e10-reception-flow/SKILL.md` |
+| Agent 调用客户参观接待 CLI 的具体 reference（抽取口径/面板约束/建单口径） | `skills/weaver-e10-reception-flow/references/` |
 | Agent 调用 OKR 目标管理 CLI 的入口路由 | `skills/weaver-e10-okr/SKILL.md` |
 | Agent 调用 OKR 目标管理 CLI 的具体 reference | `skills/weaver-e10-okr/references/` |
 | Agent 调用 ESB 动作流 CLI 的入口路由 | `skills/weaver-e10-esb/SKILL.md` |

package/docs/agent-invoice.md

@@ -67,7 +67,7 @@ weaver-work-cli --json invoice run invoice.list --input-json '{"page_size":10,"s
 
 删除、编辑、新增同样必须使用 `prepare -> apply`。出现 `partial/write_uncertain` 时停止，不能自动重试写操作。
 
-处理“把发票填进流程表单”的场景，使用 `invoice.browse-field.data` 生成浏览按钮控件所需 JSON。处理“报销发票/自动填单”时，先读取 `invoice-reim.md`，用报销相关只读 operation 获取事前申请、工作流、表单结构、预填信息和人员上级；Agent 组装报销单结构化 JSON 后，必须通过 `invoice.reim.flow.create.prepare/apply` 或 `invoice.reim.flow.update.prepare/apply` 写入，创建报销单的 `work_flow_id/mainFormId/request_name/main_fields/detail_rows` 等字段在 operation 顶层传入，不包通用 `payload`。处理“开票”时默认读取 `invoice-issuing-workflow.md`：用 `invoice.issuing.qys.list` 的 `groups` 按合同号选定一组，确认后调用 `weaver-e10-workflow` 的 `workflow.createForm` / `workflow.createRequest`（`action` 固定 `draft`）发起开票流程草稿。只有用户明确要求“直接开票/不走流程/存待开台账”时，才读取 `invoice-issuing-qys-ledger.md`（台账行）或 `invoice-issuing.md` + `invoice-issuing-field-rules.md`（口述字段），走 `invoice.issuing.make.prepare/apply`。当前修正资料包没有客户档案查询或红字发票红冲接口，`invoice.customer.*` 和 `invoice.red.*` 不能调用或绕过。
+处理“把发票填进流程表单”的场景，使用 `invoice.browse-field.data` 生成浏览按钮控件所需 JSON。处理“报销发票/自动填单”时，先读取 `invoice-reim.md`，用报销相关只读 operation（`invoice.reim.candidates.list`、`invoice.reim.requests.list`、`invoice.reim.workflow.resolve`、`invoice.reim.employee-superiors`、`invoice.reim.field.search`）获取候选发票、事前申请、工作流、人员上级和相关客户/项目；报销单的载入、创建和修改统一走 `weaver-e10-workflow`：`workflow.createForm` 载入表单，`workflow.createRequest`（`action` 固定 `draft`）存草稿，修改走 `workflow.editLoad` / `workflow.editPrepare` / `workflow.editApply`。旧的 `invoice.reim.flow.create/update.*` 已移除，不要再调用。处理“开票 / 待开票合同”时读取 `invoice-issuing-workflow.md`：先用 `weaver-e10-workflow` 的 `workflow.search` 查出当前用户有权限看的合同审批流程，再把 `data.cards` 传给 `invoice.issuing.contracts.list` 补齐是否开票、合同号、客户名称和开票金额，列出待开票合同；用户选定后用 `invoice.issuing.contract.detail` 取合同客户与合同正文文档 id，按销售方选开票申请流程，问清预计收款时间并确认后用 `workflow.createForm` / `workflow.createRequest`（`action` 固定 `draft`）存草稿。当前修正资料包没有客户档案查询或红字发票红冲接口，`invoice.customer.*` 和 `invoice.red.*` 不能调用或绕过。
 
 ## 暂缓能力
 

package/docs/archive-oa.md

@@ -68,7 +68,7 @@ weaver-work-cli --json archive-oa run archive-oa.contract.list --input-json '{"p
 ## 写操作确认协议
 
 - `*.prepare`：只读回查与参数校验（加入借阅车会查一次借阅车现状），返回 `preview` 与 `continuation`。
-- `*.apply`：必须带 `continuation` 且 `confirm: true`（CLI `--yes`）；票据含环境与登录账号指纹，10 分钟有效。
+- `*.apply`：必须带 `continuation` 且 `confirm: true`（CLI `--yes`）；票据含环境与登录账号指纹，24 小时有效。
 - 发起借阅用 `archive-oa.borrow.start.url` 生成流程页 URL（只读，`risk: read`）：生成后优先用系统默认浏览器打开，无法打开时原样输出完整 URL；流程表单由用户在浏览器确认并提交。OpenESB 版 `borrow.start.prepare` / `.apply` 已下线。
 - `failNum > 0` 时返回 `partial / write_uncertain`，不自动重放。