weaver-work-cli 0.1.40 → 0.1.42

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/docs/e10-auth.md

@@ -76,7 +76,7 @@ XiaoE 宿主身份有两种判定入口：桌面客户端由 Agent 根据“智
 
 CLI 依次尝试成对的平台凭据、npm 包自带的 `scripts/xiaoe_env.py` 兼容路径、宿主 `xiaoeUserData/tokens.py`、桌面 XiaoE 客户端本地会话和 `WEAVER_XIAOE_*` ETEAMSID 映射。客户端会话优先读取 `XIAOE_USER_SETTINGS_PATH`，再从 `XIAOE_ROBOT_DATA_ROOT` / `XIAOE_ROBOT_ROOT` 查找，最后回退 macOS `~/Library/Application Support/XiaoE/Robots/<id>/user_settings.json` 或 Windows `%LOCALAPPDATA%/XiaoE/Robots/<id>/user_settings.json`。这些变量和文件只用于定位凭据，不能用于识别宿主。`XIAOE_DOMAIN` 是 XiaoE/erpa 换票服务地址，不是 E10 登录地址。
 
-E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置/映射 → 当前 profile → `https://www.e-cology.com.cn`”解析。凭证可用时，CLI 直接保存登录态，保存的 `agentType` 固定为 `XiaoE`。统一登录失败时，所有操作系统都返回 `authentication/xiaoe_credential_unavailable`，不启动浏览器 OAuth。需要浏览器授权时必须另行显式执行 `auth login`。
+E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置/映射 → 当前 profile → `https://www.e-cology.com.cn`”解析。凭证可用时，CLI 直接保存登录态，保存的 `agentType` 固定为 `XiaoE`。统一登录失败时，所有操作系统都返回 `authentication/xiaoe_credential_unavailable`（若失败全程都是网络错误则返回 `authentication/xiaoe_network_unavailable`，提示“暂时无法连接 E10，请稍后重试”并标记为可重试），不启动浏览器 OAuth。需要浏览器授权时必须另行显式执行 `auth login`。
 
 脚本兼容链路会先自动发现桌面 XiaoE 客户端内置 Python（macOS 应用包与 Windows 按用户/全局安装均支持），再回退到系统 `python3`、`/usr/bin/python3`、`python`；Windows 的系统回退顺序为 `python`、`python3`、`py`。可用 `WEAVER_XIAOE_TOKEN_SCRIPT_PYTHON` 精确指定解释器，用 `WEAVER_XIAOE_TOKEN_SCRIPT_PATH` 指定桌面宿主脚本路径（旧名 `XIAOE_TOKEN_SCRIPT_PYTHON` / `XIAOE_TOKEN_SCRIPT_PATH` 仍兼容）。CLI 自带的 `xiaoe_env.py` 位于 npm 包 `scripts/`，不会放入 `weaver-e10-shared` Skill；Skill 包禁止携带或直接执行 Token 脚本。`XIAOE_` 是平台保留前缀，本 CLI 的自定义变量统一使用 `WEAVER_XIAOE_*`。
 
@@ -84,12 +84,18 @@ E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置
 
 XiaoE 换票结果中的 `expiryTimes` 按 Unix 毫秒时间戳持久化。宿主脚本未返回该字段时，CLI 与 XiaoE `tokens.py` 保持一致，按换票成功时间加 2 小时生成。业务命令加载会话后或长进程每次请求前发现当前时间达到 `expiryTimes` 时，会先静默重新换票；换票失败则停止本次业务请求，不会继续发送已知过期的 ETEAMSID。
 
+小 e 换票接口、`teamsCheck` 与本地会话探测都带 15 秒超时（含读响应体）。超时按网络错误处理（`causeCode=ETIMEDOUT`），不会再出现某一步没有上限、把整条命令挂死的情况；`auth status` 之类的富化请求超时后只是放弃更新信息，不影响命令本身。
+
 业务命令缺少可读取的本地会话时，若当前运行时已通过 `XIAOE_*`、`--runtime-agent xiaoe` 等标记识别为 XiaoE，公共会话加载层会先静默尝试统一登录，成功后继续业务操作。失败时返回 `authentication/xiaoe_credential_unavailable`，并明确提示已尝试自动获取。显式 `--auth` 不触发此恢复；未识别到 XiaoE 的首次认证仍需显式选择登录方式。`auth status --no-check` 等本地状态查询不会主动登录。已有 XiaoE 会话被 E10 接口明确拒绝为失效时，公共请求运行时会根据持久化会话的 `agentType` / `loginSource` 静默换票并重放原请求一次；这条路径不依赖 shared Skill、Agent、`XIAOE_*` 或 `--runtime-agent xiaoe`。它不会打印中间登录步骤，不会自动打开浏览器，也不会对流式请求、网络错误、`partial` / `write_uncertain` 做重放。`--runtime-agent xiaoe` 表示当前运行时身份，不携带凭据。WorkBuddy、Codex 及其他智能体首次认证使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
 
 无法使用浏览器回调时，可以用 `auth set` 直接写入浏览器中复制到的
 `ETEAMSID`。命令会调用 `teamsCheck` 解析当前用户、租户和组织信息，并写入
 E10 兼容的 auth 文件。
 
+静默恢复失败时，`authentication/xiaoe_credential_unavailable` 会带 `details` 以便定位而不必复现：`attemptedSteps` 按序记录评估过的凭证通道及结果（如 `platform_token:missing`、`bundled_env_script:failed`、`token_script:disabled`、`environment_map:empty`、`e10_session:failed`），`failures` 按发生顺序保留每一次失败的阶段（`platform_token` / `bundled_env_script` / `token_script` / `client_session` / `teams_check` / `e10_session`）、类别（`network` / `http` / `credential`）以及网络错误的系统错误码 `causeCode`（取自 `error.cause.code`，如 `ECONNREFUSED`、`ETIMEDOUT`）和 HTTP 错误的状态码 `httpStatus`，`lastError` 是最后一条真实原因（已对已知凭据脱敏并截断到 300 字符），并附带解析出的 `baseUrl`、`clientType`、`platformCredentialDetected`、整体归类 `errorKind` 与最后失败阶段 `failureStage`；若票其实换到了、但按 `expiryTimes` 判定为已过期，会额外带 `resultSessionExpired: true`。当且仅当所有失败都是网络错误时，错误改为 `authentication/xiaoe_network_unavailable`、`retryable: true`，文案换成“暂时无法连接 E10，请稍后重试”（此时登录态并未被验证，提示用户重新登录属于误导）。这条路径默认依然完全无输出，需要看每一步的过程日志时给业务命令加 `--verbose`（经 stderr 以 `[debug]` 前缀输出；`--json` 下完全不输出）。
+
+网页端若返回 `details.reason=host_credential_not_injected`，表示沙箱仍带 `XIAOE_CLIENT_TYPE=cloud` 标记，但宿主注入的平台凭据在启动子进程时丢失。这不是 E10 登录损坏，也不能通过重试或浏览器 OAuth 自愈；沙箱启动器必须保留宿主环境并只定向覆盖 `WEAVER_WORK_CLI_AUTH_ROOT` 等测试变量，不得用 `env -i`、空环境字典或不包含 XiaoE 平台凭据的白名单启动 CLI。凭据值不得写入命令、日志或错误详情。
+
 `auth whoami` 默认读取本地缓存，不发网络请求；`auth whoami --live` 会调用
 `teamsCheck` 获取实时信息。`auth export-weaver-env` 会输出
 `WEAVER_BASE_URL`、`WEAVER_ETEAMSID`、`WEAVER_COOKIE`、`WEAVER_USER_AGENT` 和

package/docs/operation-manual.md

@@ -381,6 +381,14 @@ dist/weaver-e10-<module>-skill.zip
 
 打包单个业务模块时会自动包含 `weaver-e10-shared`。zip 用于平台导入、离线分发或版本归档；本机日常安装优先使用 `weaver-work-cli skills install <module>`。
 
+若目标环境已装有共享 skill、只需分发业务模块本身，加 `--no-shared`（脚本位置参数之后）：
+
+```bash
+node scripts/package-skill.mjs yepiaotong dist/weaver-e10-yepiaotong-only.zip --no-shared
+```
+
+此时产物内只有业务模块目录，`../weaver-e10-shared/` 的相对引用需由目标环境自行提供。
+
 ## 10. 安装新生成的业务模块 Skill
 
 检测通过并得到用户确认后安装：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weaver-work-cli",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "面向泛微工作工具链的可扩展 TypeScript CLI 基础框架（E10 业票通等能力）",
   "type": "module",
   "main": "./dist/index.js",

package/scripts/install-skill-to-xiaoe.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * 把仓库里的 weaver-e10-meeting 技能铺到小E 的 user-skills 目录（一键恢复）。
+ *
+ * 背景（2026-11-04）：小E 的「更新 skill」会从平台技能库拉 2.11.0 覆盖本地，
+ * 而且有一次直接把 `user-skills/weaver-e10-meeting` 主目录删了（只剩 .backup-*），
+ * 导致模型读到旧版本、按旧规则把用户推去页面手工建会。
+ *
+ * 用法：node scripts/install-skill-to-xiaoe.mjs
+ * 做的事：
+ *   1. 找 AppData/Local/xiaoeUserData/userdata/<id>/user-skills；
+ *   2. 复制仓库 skills/weaver-e10-meeting 全部文件过去；
+ *   3. 保留/恢复 .skill-id（优先原文件 → 备份目录 → base.json 的 id）；
+ *   4. 把 base.json 里该技能的 version 同步成 SKILL.md frontmatter 的版本。
+ */
+import { existsSync, readFileSync, readdirSync, statSync, copyFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, '..');
+const skillSrc = path.join(repoRoot, 'skills', 'weaver-e10-meeting');
+const SKILL_NAME = 'weaver-e10-meeting';
+
+const localAppData = process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || '', 'AppData', 'Local');
+const userdataRoot = path.join(localAppData, 'xiaoeUserData', 'userdata');
+if (!existsSync(userdataRoot)) {
+  console.error(`找不到小E 数据目录：${userdataRoot}`);
+  process.exit(1);
+}
+
+const version = (() => {
+  const text = readFileSync(path.join(skillSrc, 'SKILL.md'), 'utf8').replace(/\r\n/g, '\n');
+  const m = text.match(/^version:\s*(.+)$/m);
+  return m ? m[1].trim() : '';
+})();
+
+let installed = 0;
+// 2026-11-04 实测：小E 真正加载的是**租户级** `tenant-skills`（优先级更高），
+// `user-skills` 那份会被平台「更新 skill」重置回 2.11.0，所以两个目录都要铺。
+for (const scope of ['tenant-skills', 'user-skills']) {
+  for (const userDir of readdirSync(userdataRoot)) {
+    const skillsRoot = path.join(userdataRoot, userDir, scope);
+    if (!existsSync(skillsRoot)) continue;
+    installInto(skillsRoot);
+  }
+}
+
+function installInto(skillsRoot) {
+  const target = path.join(skillsRoot, SKILL_NAME);
+
+  // 1) 保留原 .skill-id；没有就从备份目录找；再没有就从 base.json 的条目取
+  let skillId = '';
+  try {
+    skillId = readFileSync(path.join(target, '.skill-id'), 'utf8').trim();
+  } catch { /* 主目录被删过就没有 */ }
+  if (!skillId) {
+    const backup = readdirSync(skillsRoot).find((name) => name.startsWith('.backup') && name.includes('meeting'));
+    if (backup) {
+      try {
+        skillId = readFileSync(path.join(skillsRoot, backup, '.skill-id'), 'utf8').trim();
+      } catch { /* ignore */ }
+    }
+  }
+  const baseJsonPath = path.join(skillsRoot, 'base.json');
+  let base = null;
+  if (existsSync(baseJsonPath)) {
+    try {
+      base = JSON.parse(readFileSync(baseJsonPath, 'utf8'));
+      const entry = (base.skills ?? []).find((s) => s.name === SKILL_NAME);
+      if (!skillId) skillId = String(entry?.id ?? '');
+    } catch { /* ignore */ }
+  }
+
+  // 2) 复制技能文件
+  const copyDir = (rel) => {
+    const srcDir = path.join(skillSrc, rel);
+    const dstDir = path.join(target, rel);
+    mkdirSync(dstDir, { recursive: true });
+    for (const name of readdirSync(srcDir)) {
+      const src = path.join(srcDir, name);
+      const dst = path.join(dstDir, name);
+      if (statSync(src).isDirectory()) copyDir(rel ? `${rel}/${name}` : name);
+      else copyFileSync(src, dst);
+    }
+  };
+  copyDir('');
+
+  // 3) 写回 .skill-id
+  if (skillId) writeFileSync(path.join(target, '.skill-id'), skillId, 'utf8');
+
+  // 4) 同步 base.json 版本
+  if (base) {
+    const entry = (base.skills ?? []).find((s) => s.name === SKILL_NAME);
+    if (entry) {
+      entry.version = version;
+      entry.updateTime = Date.now();
+      writeFileSync(baseJsonPath, JSON.stringify(base, null, 2), 'utf8');
+    }
+  }
+
+  installed += 1;
+  console.log(`已铺装：${target}（version=${version}，skillId=${skillId || '未取到'}）`);
+}
+if (installed === 0) console.error('没有找到可铺装的 user-skills 目录');

package/scripts/package-skill.mjs

@@ -15,7 +15,9 @@ const packageJsonPath = path.join(repositoryRoot, 'package.json')
 const sharedSkillName = 'weaver-e10-shared'
 const skillPrefix = 'weaver-e10-'
 const legacySkillPrefix = 'weaver-work-cli-'
-const [requestedSkillArg, outputArg] = process.argv.slice(2)
+const rawArgs = process.argv.slice(2)
+const includeShared = !rawArgs.includes('--no-shared')
+const [requestedSkillArg, outputArg] = rawArgs.filter((arg) => !arg.startsWith('--'))
 
 function sha256(value) {
   return createHash('sha256').update(value).digest('hex')
@@ -59,7 +61,7 @@ async function resolveSkillNames() {
   if (!requestedSkill) return allSkills
   if (!allSkills.includes(requestedSkill)) throw new Error(`未知 Skill：${requestedSkill}`)
   const names = []
-  if (requestedSkill !== sharedSkillName && allSkills.includes(sharedSkillName)) names.push(sharedSkillName)
+  if (includeShared && requestedSkill !== sharedSkillName && allSkills.includes(sharedSkillName)) names.push(sharedSkillName)
   names.push(requestedSkill)
   return names
 }