weaver-work-cli 0.1.20 → 0.1.22

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

@@ -1211,7 +1211,13 @@ function remarkIdentityName(rawName, remarkValue) {
         return '';
     return REMARK_IDENTITY_NAMES[String(Number(text))] ?? '';
 }
-function normalizeListResponse(response, category, categoryName, baseUrl = '') {
+/** 列表响应归一化（来源：Python normalize_workflow_list_response）。
+ *
+ * `includeSummary` 决定卡片是否渲染摘要行（见 `renderCardMarkdown`）：legacy / 低版本模式传
+ * `true`（标题/摘要/辅助三行），smart / 智能分组模式与 `batchType` 批量取数保持 `false`
+ * （标题/辅助两行）。
+ */
+function normalizeListResponse(response, category, categoryName, baseUrl = '', includeSummary = false) {
     const record = responseData(response);
     const data = record?.data && typeof record.data === 'object' ? record.data : {};
     const records = toArray(record?.data?.displayData ?? record?.displayData ?? record?.data?.list ?? record?.list ?? []);
@@ -1261,7 +1267,12 @@ function normalizeListResponse(response, category, categoryName, baseUrl = '') {
                 recordObj.requestLevel),
             badges: uniqueBadges,
             badgeObjects: buildBadgeObjects(uniqueBadges),
+            // 摘要槽位初始值（来源：Python normalize_workflow_list_response 的 item 构造）：
+            // 逐卡补详情（enrichWorkflowCardSummaries → applyCardSummaryResult）会原地改写这三个键。
+            summaryFields: [],
+            summarySource: 'pendingDetailSummary',
         };
+        item.cardSummary = '摘要暂未生成，可打开流程查看';
         item.cardMeta = buildCardMeta(item, category);
         return item;
     });
@@ -1283,6 +1294,11 @@ function normalizeListResponse(response, category, categoryName, baseUrl = '') {
             const card = {
                 index: item.index,
                 title: item.flowName,
+                summary: item.cardSummary,
+                summarySource: item.summarySource,
+                summaryFields: item.summaryFields,
+                // 发起人姓名等禁止进入摘要的词（脚本生成摘要时过滤，见 generateBusinessSummary）
+                summaryForbiddenTerms: listSummaryForbiddenTerms(item),
                 badges: item.badges,
                 badgeObjects: item.badgeObjects,
                 meta: item.cardMeta,
@@ -1305,7 +1321,7 @@ function normalizeListResponse(response, category, categoryName, baseUrl = '') {
                 },
             };
             card.url = cardWorkflowOpenUrl(card, baseUrl);
-            card.renderMarkdown = renderCardMarkdown(card);
+            card.renderMarkdown = renderCardMarkdown(card, includeSummary);
             return card;
         }),
     };
@@ -1620,8 +1636,19 @@ const workflowSearch = {
                 finalMarkdown: buildSearchFinalMarkdown(null, probes, total, category, true, searchMode === 'smart', waitReadTotal),
             });
         }
-        const normalized = normalizeListResponse(listResponse, category, CATEGORY_NAMES[category], session.baseUrl ?? '');
+        // 卡片摘要行只在 **legacy（低版本模式）** 生成——契约见 references/workflow-query.md
+        // 「执行模式与返回形态」的「卡片摘要行」一行（低版本=标题/摘要/辅助三行；智能分组=标题/辅助
+        // 两行）。`batchType` 批量取数只关心 requestId，跳过摘要、不白跑 N 次详情接口
+        // （来源：Python execute_workflow_search_legacy 的 `include_summary=True` 与 batch 分支
+        // 强制 `no_card_summaries`）。
+        const withCardSummaries = searchMode === 'legacy' && !batchType;
+        const normalized = normalizeListResponse(listResponse, category, CATEGORY_NAMES[category], session.baseUrl ?? '', withCardSummaries);
         normalized.total = total;
+        // 先把当前页卡片补上摘要，再落索引——这样序号定位拿到的 items 也带摘要（V11.3 同步了
+        // sessionMapPayload，本实现改为「补完再落盘」，语义等价）。
+        if (withCardSummaries) {
+            await enrichWorkflowCardSummaries(env, normalized, asInt(args.pageSize) ?? normalized.pageSize);
+        }
         const index = await saveListIndex(env, normalized);
         return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
             type: 'workflowSearch',
@@ -1634,7 +1661,7 @@ const workflowSearch = {
             // 条目只输出机器可读的定位/标识/可操作性字段——渲染一律用 finalMarkdown，
             // 不再回显渲染字段（此前 cards / cardItems / renderMarkdown 三份互相重复）。
             cards: normalized.items.map(slimIndexItem),
-            finalMarkdown: buildSearchFinalMarkdown(normalized, probes, total, category, false, searchMode === 'smart', waitReadTotal),
+            finalMarkdown: buildSearchFinalMarkdown(normalized, probes, total, category, false, searchMode === 'smart', waitReadTotal, withCardSummaries),
             queryId: index.queryId,
             sessionMap: { queryId: index.queryId, itemCount: normalized.items.length },
         }, env, { json: 'last_search.json', md: 'last_search.md' }));
@@ -1701,7 +1728,7 @@ function todoProbeNotice(probes) {
     return `另外，该条件下有${parts.join('、')}，建议优先关注。`;
 }
 /** workflow.search 最终 Markdown（来源：Python build_workflow_search_final_markdown） */
-function buildSearchFinalMarkdown(normalized, probes, total, category, totalOnly, smartMode, waitReadTotal = null) {
+function buildSearchFinalMarkdown(normalized, probes, total, category, totalOnly, smartMode, waitReadTotal = null, includeSummary = false) {
     const label = CATEGORY_NAMES[category];
     const lines = [];
     if (totalOnly) {
@@ -1724,7 +1751,7 @@ function buildSearchFinalMarkdown(normalized, probes, total, category, totalOnly
             lines.push(`另有 ${asInt(waitReadTotal)} 条待阅流程。`);
         }
     }
-    const body = normalized ? renderListMarkdown(normalized) : '';
+    const body = normalized ? renderListMarkdown(normalized, includeSummary) : '';
     if (body)
         lines.push(body);
     return lines.filter(Boolean).join('\n\n');
@@ -1795,19 +1822,27 @@ function todoTabName(tabid) {
     return '待处理';
 }
 /** 取一组待办明细（list 接口）并按请求窗口归一化（来源：Python normalize_todo_group_list）。 */
-async function fetchLegacyTodoGroupList(env, query, total, baseUrl) {
+/** 取一个待办分组的分页明细（来源：Python normalize_todo_group_list，L11987）。
+ *
+ * 低版本模式（legacy）走 CLI 侧分组，卡片同样是**三行**（契约见 references/workflow-query.md
+ * 「卡片摘要行」一行）——这里就地补当前页前 `summaryLimit` 张卡片的摘要
+ * （来源：Python `normalize_todo_group_list` 内的 `enrich_workflow_card_summaries`）。
+ */
+async function fetchLegacyTodoGroupList(env, query, total, baseUrl, summaryLimit = 0) {
     const response = await env.host.workflowRequest({
         method: 'POST',
         path: WORKFLOW_ENDPOINTS.TODO_LIST,
         operation: 'workflow.search.group.list',
         body: query,
     });
-    const normalized = normalizeListResponse(response, 'todo', CATEGORY_NAMES.todo, baseUrl);
+    const normalized = normalizeListResponse(response, 'todo', CATEGORY_NAMES.todo, baseUrl, true);
     const window = (query.customDisplayPage || {});
     normalized.current = asInt(window.current) ?? normalized.current;
     normalized.pageSize = asInt(window.size) ?? normalized.pageSize;
     normalized.total = total;
     normalized.hasMore = (asInt(normalized.pageSize) ?? 0) * (asInt(normalized.current) ?? 1) < total;
+    if (summaryLimit > 0)
+        await enrichWorkflowCardSummaries(env, normalized, summaryLimit);
     return normalized;
 }
 /** 跨组去重：剔除已被更高优先级分组展示过的流程（来源：Python filter_group_normalized_to_unseen）。 */
@@ -1863,7 +1898,7 @@ function combineLegacyTodoGroups(groupResults) {
         for (const card of cards) {
             const rid = asString(card?.internal?.requestId) ?? '';
             card.index = groupIndex;
-            card.renderMarkdown = renderCardMarkdown(card);
+            card.renderMarkdown = renderCardMarkdown(card, true);
             const item = itemByRid.get(rid);
             if (item) {
                 item.index = groupIndex;
@@ -1949,6 +1984,11 @@ async function executeLegacyGroupedTodoSearch(env, args) {
     const baseUrl = session.baseUrl ?? '';
     const mainSize = Math.max(1, Math.min(asInt(args.pageSize) ?? 10, 100));
     const auxSize = Math.min(mainSize, 5);
+    // 摘要补全条数：主组 = min(主列表页大小, 页大小)，特殊组 = min(3, 页大小)
+    // （来源：Python execute_grouped_todo_search 的 summary_limit_main / summary_limit_aux）
+    const summaryItemLimit = asInt(args.pageSize) ?? mainSize;
+    const summaryLimitMain = Math.min(mainSize, summaryItemLimit);
+    const summaryLimitAux = Math.min(3, summaryItemLimit);
     const mainTabid = tabid || SUB_CATEGORY_TABS.todo['待处理'];
     const mainQuery = todoQueryForTab(query, mainTabid, mainSize);
     const personalQuery = todoQueryForTab(query, '7', mainSize);
@@ -2021,12 +2061,13 @@ async function executeLegacyGroupedTodoSearch(env, args) {
     const mainListQuery = fallbackToAll ? allQuery : mainQuery;
     const mainListTotal = fallbackToAll ? allTotal : mainTotal;
     const listJobs = {
-        main_list: fetchLegacyTodoGroupList(env, mainListQuery, mainListTotal, baseUrl),
+        main_list: fetchLegacyTodoGroupList(env, mainListQuery, mainListTotal, baseUrl, summaryLimitMain),
     };
-    if (showOverdue)
-        listJobs.overdue_list = fetchLegacyTodoGroupList(env, overdueQuery, overdueTotal, baseUrl);
+    if (showOverdue) {
+        listJobs.overdue_list = fetchLegacyTodoGroupList(env, overdueQuery, overdueTotal, baseUrl, summaryLimitAux);
+    }
     if (showUrgent) {
-        listJobs.urgent_list = fetchLegacyTodoGroupList(env, urgentQuery, urgentTotal, baseUrl);
+        listJobs.urgent_list = fetchLegacyTodoGroupList(env, urgentQuery, urgentTotal, baseUrl, summaryLimitAux);
     }
     const listPairs = await Promise.all(Object.entries(listJobs).map(async ([key, task]) => [key, await task]));
     const lists = {};
@@ -2186,11 +2227,17 @@ function extractTotal(response) {
     }
     return null;
 }
-/** 单张卡片的三行 Markdown：标题行（含徽标）+ 元信息行（来源：Python render_card_markdown）。
+/** 单张卡片的 Markdown：标题行（含徽标）+ **可选**摘要行 + 元信息行（来源：Python render_card_markdown）。
+ *
+ * `includeSummary` 决定是否渲染摘要行（第 2 行）——**契约**见 `references/workflow-query.md`
+ * 「执行模式与返回形态」的「卡片摘要行」一行：
+ * - `true`（legacy / 低版本模式）→ **标题/摘要/辅助三行**，摘要由 `enrichWorkflowCardSummaries`
+ *   逐卡补详情（REQUEST_DETAIL）后生成；
+ * - `false`（smart / 智能分组模式，以及 `batchType` 批量取数）→ **标题/辅助两行**。
  *
- * smart（智能分组）模式不渲染摘要行——与 Python `include_summary=False` 一致。
+ * 默认 `false`：避免未经富化的卡片被渲染出一行占位摘要（`batchType` 与 plan 卡片都不补摘要）。
  */
-function renderCardMarkdown(card) {
+function renderCardMarkdown(card, includeSummary = false) {
     const badgeTexts = (card.badgeObjects || [])
         .map((badge) => stripHtml(badge?.text))
         .filter(Boolean)
@@ -2208,15 +2255,25 @@ function renderCardMarkdown(card) {
     const url = asString(card.url) ?? '';
     const title = url ? `[${stripHtml(titleText)}](${url})` : stripHtml(titleText);
     const lines = [`**${title}**${badges}  `];
+    if (includeSummary) {
+        let summaryText = stripHtml(card.summary ?? '');
+        // 脚本自动摘要信息量不足时被标记为 needsModelSummary，摘要行给占位提示，
+        // 模型基于 summaryContext 生成后替换（来源：Python render_card_markdown 的占位分支）。
+        if (card.needsModelSummary && (!summaryText || summaryText === '摘要暂未生成，可打开流程查看')) {
+            summaryText = '（摘要待模型生成）';
+        }
+        lines.push(`${summaryText}  `);
+    }
     if (meta)
         lines.push(meta);
     return lines.join('\n');
 }
-function renderListMarkdown(normalized) {
+/** 卡片列表 Markdown：`includeSummary` 透传给单卡渲染（见 `renderCardMarkdown`）。 */
+function renderListMarkdown(normalized, includeSummary = false) {
     const items = normalized.cardItems || [];
     if (!items.length)
         return '无匹配流程';
-    return items.map((card) => renderCardMarkdown(card)).join('\n\n---\n\n');
+    return items.map((card) => renderCardMarkdown(card, includeSummary)).join('\n\n---\n\n');
 }
 // plan 取数分页口径（来源：Python _PLAN_GROUP_FETCH_PAGE_SIZE / _PLAN_GROUP_FETCH_MAX_PAGES
 // 与 _plan_execute_slot 的 pageSize=100 / max_pages=500）
@@ -3756,13 +3813,627 @@ const DETAIL_SUMMARY_BOOL_QUESTION_PATTERN = /^(是否|是否为|是否包含|
 const DETAIL_SUMMARY_REGISTER_META_PATTERN = /(备案|环境|版本|基线|编号|序号|编码|流水号|工单|紧急|优先级|级别|程度|渠道|来源|状态)/;
 const DETAIL_SUMMARY_WORKFLOW_META_PATTERN = /^(发起|提交|创建|制单|填报).*(人|时间)$|(当前|审批|处理|流转|流程|待办).*(节点|状态)|(停留|超时|到达当前节点).*(时间|时长)|^(节点|状态|审批中|已结束|草稿)$/;
 const SUMMARY_MEANINGLESS_VALUES = new Set(['0', '无', '暂无', '无内容', '-', '--', 'null', 'none', 'undefined', '请填写', '请选择']);
+// 内容信息量评分的取值信号（来源：Python SUMMARY_STRUCTURED_LIST_ITEM_PATTERN 等，L941-944）
+const SUMMARY_STRUCTURED_LIST_ITEM_PATTERN = /(?:^|[\n；;])\s*[1-9一二三四五六七八九十]\s*[、.．]/g;
+const SUMMARY_VALUE_LABEL_PATTERN = /(需求概述|事项|说明|原因|背景|价值|目标|方案|内容|描述)\s*[:：]/;
+const SUMMARY_VALUE_AMOUNT_PATTERN = /\d+(?:\.\d+)?\s*(?:元|天|小时|工时|日|万|%|％)/;
+const SUMMARY_VALUE_DATE_PATTERN = /\d{4}[-/年]\d{1,2}/;
+// 语义角色的补充模式（来源：Python SUMMARY_START_FIELD_PATTERN / SUMMARY_END_FIELD_PATTERN /
+// SUMMARY_ROLE_WORD_PATTERN，L1088-1097）
+const SUMMARY_START_FIELD_PATTERN = /(开始|起始|起算|生效|启用)/;
+const SUMMARY_END_FIELD_PATTERN = /(结束|截止|终止|到期|完成)/;
+const SUMMARY_ROLE_WORD_PATTERN = /(事由|原因|说明|概述|描述|内容|背景|价值|需求|事项|金额|总额|合计|预算|成本|收入|付款|收款|借款|费用|类型|类别|分类|方式|性质|用途|开始|起始|起算|生效|启用|结束|截止|终止|到期|完成|日期|时间|预计|天数|人天|工时|时长|期限|周期|负责人|责任人|主管|审批人|经手人)/g;
+// 描述类字段的提炼预算与模型兜底阈值（来源：Python L1240-1249 / L1261-1262）
+const SUMMARY_REASON_TEXT_BUDGET = 75;
+const SUMMARY_MODEL_FALLBACK_MIN_LEN = 10;
+const SUMMARY_MODEL_INSTRUCTION = '该卡片脚本自动摘要信息量不足，请基于 summaryContext 理解表单字段数据后生成中文摘要，'
+    + '优先体现申请事项、金额、时间、类别、原因、说明、核心需求/描述等业务重点；'
+    + '不要只复述流程标题，不要编造，不要出现发起人姓名；字数控制在 100 字以内。';
+/** 标签优先级（主标签「需求概述/事项/说明」排前，来源：Python SUMMARY_LABEL_PRIORITY，L1327） */
+const SUMMARY_LABEL_PRIORITY = ['需求概述', '事项', '说明', '原因', '背景', '价值'];
+/** 逐卡补详情时的并发上限。
+ *
+ * 来源：V11.3 Python `enrich_workflow_card_summaries` 的 `max_workers=min(len,4)`。
+ * **本实现有意上调为 5**（09-24 用户决策）：默认 `pageSize=5` 时 4 个 worker 必然把当前页 5 张卡
+ * 拆成 **4+1 两轮**（多一个 RTT）；5 个 worker 正好一轮打完。**改回 4 之前先确认为什么要退回。**
+ */
+const SUMMARY_ENRICH_MAX_WORKERS = 5;
+/** 详情接口在「列表卡片补摘要」链路里的短超时。
+ *
+ * 来源：V11.3 `http_timeout_seconds("REQUEST_DETAIL")` 返回 **5s**（其余接口 10s）——列表补摘要
+ * 属于尽力而为，单个详情卡顿不得拖垮整条查询。
+ */
+const SUMMARY_DETAIL_TIMEOUT_MS = 5_000;
+/** 按**字符**数截断，优先在中文标点边界收尾（来源：Python truncate_text，L848）。
+ *
+ * 与 `truncateUtf8Text`（按字节硬截，服务 stdout 预算）是两件事：本函数按字符计数，并在 limit
+ * 内最后一个中文标点处收尾，避免把句子/词截成半截（如「…是流程引擎的待…」）。`stripHtml`
+ * 已完成空白折叠与首尾裁剪，与 Python 里先 `re.sub(r"\s+"," ")` 再 `strip()` 等价。
+ */
+function truncateText(value, limit = 120) {
+    const text = stripHtml(value);
+    if (text.length <= limit)
+        return text;
+    let cut = limit;
+    for (const sep of ['。', '！', '？', '；', '，', '、', '：']) {
+        const idx = text.lastIndexOf(sep, limit - 1);
+        if (idx >= Math.floor(limit * 0.5) && idx + 1 > cut)
+            cut = idx + 1;
+    }
+    return `${text.slice(0, cut).replace(/[ ，、；：。！？]+$/g, '')}…`;
+}
+/** 字段内容信息量评分（来源：Python score_summary_field_value，L947）。
+ *
+ * 内容理解优先、字段名仅作权重：结构化编号列表 > 标签结构 > 长文本 > 业务数字/日期。
+ * 解决「表单顺序第一个命中描述模式」让短泛化字段挤掉核心长文本的问题。
+ */
+function scoreSummaryFieldValue(name, value) {
+    const text = (value ?? '').trim();
+    if (!text)
+        return 0;
+    let score = 0;
+    const numberedItems = text.split(SUMMARY_STRUCTURED_LIST_ITEM_PATTERN).length - 1;
+    if (numberedItems >= 2)
+        score += 12;
+    else if (numberedItems)
+        score += 6;
+    if (SUMMARY_VALUE_LABEL_PATTERN.test(text))
+        score += 8;
+    if (text.length >= 200)
+        score += 10;
+    else if (text.length >= 50)
+        score += 6;
+    else if (text.length >= 20)
+        score += 3;
+    if (SUMMARY_VALUE_AMOUNT_PATTERN.test(text))
+        score += 5;
+    else if (SUMMARY_VALUE_DATE_PATTERN.test(text))
+        score += 4;
+    if (/(概述|描述|事项|说明)/.test(name))
+        score += 4;
+    else if (/(原因|背景|价值|需求|内容)/.test(name))
+        score += 2;
+    return score;
+}
+/** 描述类字段按信息量降序（来源：Python best_reason_fields，L1100）。稳定排序，同分保持表单顺序。 */
+function bestReasonFields(fields) {
+    const candidates = [];
+    for (const field of fields) {
+        const name = stripHtml(field?.fieldName ?? '');
+        const value = stripHtml(field?.value ?? '');
+        if (!name || !value)
+            continue;
+        if (!SUMMARY_REASON_FIELD_PATTERN.test(name))
+            continue;
+        candidates.push({ fieldName: name, value, componentKey: asString(field?.componentKey) ?? '' });
+    }
+    candidates.sort((a, b) => scoreSummaryFieldValue(b.fieldName, b.value) - scoreSummaryFieldValue(a.fieldName, a.value));
+    return candidates;
+}
+/** 字段归一为通用业务语义角色（来源：Python summary_semantic_role，L1127）。不依赖具体流程模板。 */
+function summarySemanticRole(field) {
+    const name = stripHtml(field?.fieldName ?? '');
+    const component = stripHtml(field?.componentKey ?? '').toLowerCase();
+    if (!name)
+        return 'other';
+    if (SUMMARY_REASON_FIELD_PATTERN.test(name))
+        return 'reason';
+    if (SUMMARY_AMOUNT_FIELD_PATTERN.test(name))
+        return 'amount';
+    if (SUMMARY_TYPE_FIELD_PATTERN.test(name))
+        return 'type';
+    const isTemporal = SUMMARY_DATE_FIELD_PATTERN.test(name) || component.includes('date') || component.includes('time');
+    if (isTemporal && SUMMARY_START_FIELD_PATTERN.test(name))
+        return 'start';
+    if (isTemporal && SUMMARY_END_FIELD_PATTERN.test(name))
+        return 'end';
+    if (SUMMARY_DAY_FIELD_PATTERN.test(name))
+        return 'duration';
+    if (SUMMARY_PERSON_FIELD_PATTERN.test(name))
+        return 'person';
+    if (isTemporal)
+        return 'date';
+    return 'other';
+}
+/** 提取字段业务前缀，让「报销原因/报销类型」等同域字段优先组合（来源：Python summary_field_stem，L1153）。 */
+function summaryFieldStem(name) {
+    return stripHtml(name)
+        .replace(SUMMARY_ROLE_WORD_PATTERN, '')
+        .replace(/^[（）()【】\[\]_\-\u2014:：/ ]+|[（）()【】\[\]_\-\u2014:：/ ]+$/g, '');
+}
+/** 单字段在指定语义角色下的得分（来源：Python semantic_field_score，L1158）。 */
+function semanticFieldScore(field, role, anchorStem = '') {
+    const name = stripHtml(field?.fieldName ?? '');
+    const value = stripHtml(field?.value ?? '');
+    const component = stripHtml(field?.componentKey ?? '').toLowerCase();
+    let score = 0;
+    if (role === 'reason') {
+        score += scoreSummaryFieldValue(name, value);
+    }
+    else if (role === 'start' || role === 'end' || role === 'date') {
+        if (/\d{4}[-/.年]\d{1,2}/.test(value))
+            score += 8;
+        else if (/\d{1,2}:\d{2}/.test(value))
+            score += 3;
+        if (component.includes('date'))
+            score += 2;
+    }
+    else if (role === 'type') {
+        score += /^[\d.]+$/.test(value) ? 0.5 : 4;
+        score += Math.min(name.length, 8) * 0.2;
+    }
+    else if (role === 'amount' || role === 'duration') {
+        score += /\d/.test(value) ? 4 : 1;
+    }
+    else {
+        score += Math.min(value.length, 20) * 0.1;
+    }
+    const stem = summaryFieldStem(name);
+    if (anchorStem && stem && (stem === anchorStem || stem.includes(anchorStem) || anchorStem.includes(stem))) {
+        score += 8;
+    }
+    return score;
+}
+/** 指定语义角色下得分最高的字段；同分取表单顺序更靠前的（来源：Python best_semantic_field，L1185）。 */
+function bestSemanticField(fields, role, anchorStem = '') {
+    const candidates = fields.filter((field) => summarySemanticRole(field) === role);
+    if (!candidates.length)
+        return null;
+    return candidates.reduce((best, field) => semanticFieldScore(field, role, anchorStem) > semanticFieldScore(best, role, anchorStem) ? field : best);
+}
+/** 起止/日期片段（来源：Python summary_temporal_fragment，L1196）。 */
+function summaryTemporalFragment(fields, anchorStem = '') {
+    const start = bestSemanticField(fields, 'start', anchorStem);
+    const end = bestSemanticField(fields, 'end', anchorStem);
+    if (start) {
+        const startName = stripHtml(start.fieldName);
+        const startValue = stripHtml(start.value);
+        const endValue = end ? stripHtml(end.value) : '';
+        if (endValue && endValue !== startValue)
+            return `${startName}${startValue}至${endValue}`;
+        return `${startName}${startValue}`;
+    }
+    const dateField = bestSemanticField(fields, 'date', anchorStem);
+    if (dateField)
+        return `${stripHtml(dateField.fieldName)}${stripHtml(dateField.value)}`;
+    return '';
+}
+/** 值补单位（来源：Python value_with_unit，L1212）。 */
+function valueWithUnit(value, unit) {
+    const text = stripHtml(value);
+    if (!text)
+        return '';
+    return text.endsWith(unit) ? text : `${text}${unit}`;
+}
+/** 按句末符号取前 N 句（来源：Python truncate_by_sentences，L1219）。
+ *
+ * 分隔符**不含英文句点**——否则版本号（`2.164.0.RELEASE`）、小数、编号会被当成句末，
+ * 摘要被截成「发布版本2.164」。
+ */
+function truncateBySentences(text, maxSentences = 2) {
+    if (!text)
+        return '';
+    const keep = [];
+    for (const part of text.split(/(?<=[。！？；;\n])/)) {
+        if (!part.trim())
+            continue;
+        keep.push(part);
+        if (keep.length >= maxSentences)
+            break;
+    }
+    return keep.join('').replace(/^[，；\s　]+|[，；\s　]+$/g, '');
+}
+/** 提炼描述类字段的核心内容（来源：Python summarize_reason_text，L1265）。
+ *
+ * 先按句级（。！？；）取前 2 句；仍超预算则按分句级（，；）累计直到接近预算，保证在语义边界
+ * 收尾；分句累计不足一半预算时退回标点边界截断。分句不含顿号「、」，否则「1、2、」等序号会被
+ * 切成独立分句，产生「…审批；2」这类残词结尾。
+ */
+function summarizeReasonText(text, maxLen = SUMMARY_REASON_TEXT_BUDGET) {
+    const value = stripHtml(text).replace(/^[ ，。；;]+|[ ，。；;]+$/g, '');
+    if (!value)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    const sentences = value.split(/(?<=[。！？；;])/).filter((sentence) => sentence.trim());
+    if (sentences.length > 1) {
+        const joined = sentences.slice(0, 2).join('').replace(/^[ ，。；;]+|[ ，。；;]+$/g, '');
+        if (joined.length <= maxLen)
+            return joined;
+    }
+    let joined = '';
+    for (const clause of value.split(/(?<=[，；])/)) {
+        if (joined.length + clause.length > maxLen)
+            break;
+        joined += clause;
+    }
+    joined = joined.replace(/^[ ，、；]+|[ ，、；]+$/g, '');
+    // 补全未闭合括号（分句常切在括号内容中间）
+    if ((joined.match(/（/g) ?? []).length > (joined.match(/）/g) ?? []).length)
+        joined += '）';
+    if (joined.length >= Math.floor(maxLen * 0.5))
+        return joined;
+    return truncateText(value, maxLen);
+}
+/** 清洗并裁剪自动摘要（来源：Python clean_generated_summary，L1301）。
+ *
+ * `splitSentences=false` 时不做整体切句——reason 分支已单独提炼过描述片段，拼接后切句会把
+ * 补充字段（金额/时间）当第 3 句切掉；此时只按长度 + 标点边界收尾。
+ */
+function cleanGeneratedSummary(text, forbiddenTerms = null, limit = 100, splitSentences = true) {
+    let value = stripHtml(text).replace(/^[ ，。；;]+|[ ，。；;]+$/g, '');
+    for (const term of forbiddenTerms ?? []) {
+        const cleanTerm = stripHtml(term);
+        if (cleanTerm)
+            value = value.split(cleanTerm).join('');
+    }
+    value = value.replace(/\s+/g, ' ').replace(/^[ ，。；;]+|[ ，。；;]+$/g, '');
+    if (splitSentences)
+        value = truncateBySentences(value, 2);
+    return truncateText(value, limit);
+}
+/** 剥离标签前的中文修饰词（来源：Python trim_label_prefix，L1330）。
+ *
+ * 「需求背景」中的「背景」被识别为低优先级标签时，标签 start 落在「背」字，前面的「需求」
+ * 会残留在上一段末尾；若 endPos 前紧邻中文，回退剥离最多 4 个修饰字。
+ */
+function trimLabelPrefix(text, endPos) {
+    let i = endPos - 1;
+    while (i >= 0 && endPos - i <= 4) {
+        const code = text.charCodeAt(i);
+        if (code < 0x4e00 || code > 0x9fff)
+            break;
+        i -= 1;
+    }
+    return i + 1;
+}
+/** 从带标签的长文本中提取核心描述内容（来源：Python extract_labeled_summary_value，L1343）。
+ *
+ * 先定位所有「标签：」出现位置（允许「需求背景」中的「背景」被识别为低优先级标签），按标签
+ * 优先级取最高优先级的标签；内容 = 该标签冒号之后、到下一个标签之前的切片。这样「需求概述」
+ * 存在时必取「需求概述」内容，「需求背景」不会抢位。过短的截断残句（长度 < 2）丢弃。
+ */
+function extractLabeledSummaryValue(value) {
+    const text = stripHtml(value);
+    if (!text)
+        return '';
+    const labelRe = new RegExp(`(${SUMMARY_LABEL_PRIORITY.join('|')})\\s*[:：]`, 'g');
+    const matches = [];
+    let matched = labelRe.exec(text);
+    while (matched !== null) {
+        matches.push({ label: matched[1], start: matched.index, end: matched.index + matched[0].length });
+        if (matched.index === labelRe.lastIndex)
+            labelRe.lastIndex += 1;
+        matched = labelRe.exec(text);
+    }
+    if (!matches.length)
+        return text;
+    const ordered = matches
+        .slice()
+        .sort((a, b) => SUMMARY_LABEL_PRIORITY.indexOf(a.label) - SUMMARY_LABEL_PRIORITY.indexOf(b.label));
+    const laterPositions = matches.filter((item) => item.start > ordered[0].start).map((item) => item.start);
+    let endPos = laterPositions.length ? Math.min(...laterPositions) : text.length;
+    if (laterPositions.length)
+        endPos = trimLabelPrefix(text, endPos);
+    const candidate = text.slice(ordered[0].end, endPos).trim();
+    // 只有「过短」才判为截断残句；较长的「…」结尾（完整编号列表）仍保留
+    if (candidate.length >= 2 && (!candidate.endsWith('…') || candidate.length >= 20))
+        return candidate;
+    for (const match of ordered.slice(1)) {
+        const later2 = laterPositions.filter((position) => position > match.start);
+        let end2 = later2.length ? Math.min(...later2) : text.length;
+        if (later2.length)
+            end2 = trimLabelPrefix(text, end2);
+        const cand2 = text.slice(match.end, end2).trim();
+        if (cand2.length >= 2 && (!cand2.endsWith('…') || cand2.length >= 20))
+            return cand2;
+    }
+    return text;
+}
+/** 摘要上下文（来源：Python build_summary_context_text，L1072）。
+ *
+ * 卡片 `needsModelSummary=true` 时，模型据此理解表单字段、生成摘要；`summaryContext` 随卡片
+ * 保留在归一化结果里（本项目的输出只保留 `finalMarkdown`，模型直接按占位提示改写该行即可）。
+ */
+function buildSummaryContextText(fields, limit = 600) {
+    const parts = fields
+        .filter((field) => field?.fieldName && field?.value)
+        .map((field) => `${field.fieldName}：${field.value}`);
+    return truncateText(parts.join('；'), limit);
+}
+/** 摘要禁用词（发起人姓名等，来源：Python list_summary_forbidden_terms，L1514）。 */
+function listSummaryForbiddenTerms(item) {
+    const terms = [];
+    const creatorName = stripHtml(item?.creatorName ?? '');
+    if (creatorName)
+        terms.push(creatorName);
+    for (const metaItem of item?.cardMeta ?? []) {
+        if (!metaItem || typeof metaItem !== 'object')
+            continue;
+        const label = stripHtml(metaItem.label);
+        const value = stripHtml(metaItem.value);
+        if (['发起人', '申请人', '发起人/申请人'].includes(label) && value)
+            terms.push(value);
+    }
+    const deduped = [];
+    const seen = new Set();
+    for (const term of terms) {
+        if (term.length < 2 || seen.has(term))
+            continue;
+        seen.add(term);
+        deduped.push(term);
+    }
+    return deduped;
+}
+/** 二次过滤：剔除人员类字段与命中禁用词的字段（来源：Python filter_card_summary_fields，L3341）。 */
+function filterCardSummaryFields(card, fields) {
+    const forbidden = new Set((card?.summaryForbiddenTerms ?? []).map((term) => stripHtml(term)).filter(Boolean));
+    const filtered = [];
+    for (const field of fields) {
+        const name = stripHtml(field?.fieldName ?? '');
+        const value = stripHtml(field?.value ?? '');
+        if (!name || !value)
+            continue;
+        if (['发起人', '申请人', '提交人', '创建人', '制单人', '填报人', '报销人员'].includes(name))
+            continue;
+        if (forbidden.has(value))
+            continue;
+        filtered.push(field);
+    }
+    return filtered;
+}
+/** 详情取不到表单数据时的卡片提示（来源：Python detail_summary_unavailable_message，L3289）。 */
+function detailSummaryUnavailableMessage(formData) {
+    if (formData && formData.available === false)
+        return '详情接口未返回表单数据，可打开流程查看';
+    return '该流程暂无表单数据，暂时无法生成摘要';
+}
+/** 详情接口失败时的卡片提示（来源：Python detail_summary_unavailable_from_error，L3535）。
+ *
+ * ⚠️ 与 V11.3 的唯一偏差：V11.3 把超时文案写死成「10 秒内未返回」，而它自己的
+ * `http_timeout_seconds("REQUEST_DETAIL")` 返回的是 **5s**（文案与实现不一致）。这里由常量派生，
+ * 保证文案与实际超时一致。
+ */
+function detailSummaryUnavailableFromError(error) {
+    const reason = String(error?.stopReason ?? '').trim();
+    if (reason === 'http_timeout')
+        return `详情接口 ${SUMMARY_DETAIL_TIMEOUT_MS / 1000} 秒内未返回，摘要暂不可用，可打开流程查看`;
+    if (reason === 'login_expired')
+        return '系统认证信息已失效，摘要暂不可用';
+    if (reason === 'api_business_error')
+        return '详情接口返回业务错误，摘要暂不可用';
+    return '该流程暂无表单数据，暂时无法生成摘要';
+}
+/** 把补摘要链路里的异常归一为 V11.3 的 `stopReason` 词表（供文案分流）。
+ *
+ * 映射：网络超时 → `http_timeout`；登录失效 → `login_expired`；接口业务/HTTP 错误 →
+ * `api_business_error`。其余（协议异常、程序缺陷）走默认文案。
+ */
+function summaryStopReasonOf(error) {
+    const structured = error;
+    if (structured?.type === 'network')
+        return structured.subtype === 'timeout' ? 'http_timeout' : 'http_status';
+    if (structured?.type === 'authentication')
+        return 'login_expired';
+    if (structured?.type === 'api')
+        return 'api_business_error';
+    return 'unknown';
+}
+/** 单卡详情补全（来源：Python fetch_card_summary_result，L3546）。
+ *
+ * 取该卡片 requestId 的详情表单字段 → 摘要候选筛选 → 返回待生成的字段清单。**不改未读状态**
+ * （`isReadRequest=false`）。失败不抛错，返回「摘要不可用」的降级结果。
+ */
+async function fetchCardSummaryResult(env, card, userId) {
+    const requestId = asString(card?.internal?.requestId) ?? '';
+    if (!requestId) {
+        return {
+            card,
+            requested: false,
+            summary: '详情接口未返回 requestId，摘要不可用',
+            source: 'workflowDetailUnavailable',
+            fields: [],
+            error: { stopReason: 'missing_request_id' },
+        };
+    }
+    let detailResponse;
+    try {
+        const payload = {
+            requestId,
+            isGetRequestBaseInfo: true,
+            isGetRequestLog: false,
+            isGetFormData: true,
+            // 列表卡片补摘要不得改变未读状态——只有用户主动查看流程内容时 isReadRequest 才为 true
+            isReadRequest: false,
+        };
+        if (userId)
+            payload.userId = userId;
+        detailResponse = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+            operation: 'workflow.search.summary.detail',
+            body: payload,
+            timeoutMs: SUMMARY_DETAIL_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        const stopReason = summaryStopReasonOf(error);
+        return {
+            card,
+            requested: true,
+            summary: detailSummaryUnavailableFromError({ stopReason }),
+            source: 'workflowDetailUnavailable',
+            fields: [],
+            error: { requestId, stopReason },
+        };
+    }
+    const detail = normalizeDetailResponse(detailResponse);
+    const formFields = Array.isArray(detail?.formData?.fields) ? detail.formData.fields : [];
+    const selectedFields = filterCardSummaryFields(card, selectSummaryFields(formFields, 12));
+    if (selectedFields.length) {
+        return {
+            card,
+            requested: true,
+            summary: '',
+            source: 'workflowDetailFormDataAutoSummary',
+            fields: selectedFields,
+            error: null,
+        };
+    }
+    return {
+        card,
+        requested: true,
+        summary: detailSummaryUnavailableMessage(detail?.formData ?? {}),
+        source: 'workflowDetailUnavailable',
+        fields: [],
+        error: null,
+    };
+}
+/** 把补摘要结果写回卡片与索引条目（来源：Python apply_card_summary_result，L3588）。
+ *
+ * 摘要行渲染统一走 `renderCardMarkdown(card, true)`——补到摘要的卡片按三行渲染。
+ */
+function applyCardSummaryResult(normalized, result) {
+    const card = result?.card;
+    if (!card || typeof card !== 'object')
+        return;
+    let summary = String(result.summary ?? '');
+    const source = String(result.source ?? 'workflowDetailUnavailable');
+    const selectedFields = Array.isArray(result.fields) ? result.fields : [];
+    const summaryContext = buildSummaryContextText(selectedFields);
+    let needsModel = false;
+    if (source === 'workflowDetailFormDataAutoSummary') {
+        const forbiddenTerms = (card.summaryForbiddenTerms ?? [])
+            .map((term) => stripHtml(term))
+            .filter(Boolean);
+        summary = generateBusinessSummary(selectedFields, forbiddenTerms) || summaryContext;
+        // 脚本自动摘要信息量不足（过短/空）→ 标记 needsModelSummary，保留
+        // summaryFields/summaryContext/summaryInstruction 交模型理解字段数据后生成
+        if (stripHtml(summary).length < SUMMARY_MODEL_FALLBACK_MIN_LEN) {
+            summary = '摘要暂未生成，可打开流程查看';
+            needsModel = true;
+        }
+    }
+    card.summary = summary;
+    card.summarySource = source;
+    card.summaryFields = selectedFields;
+    card.summaryContext = summaryContext;
+    card.needsModelSummary = needsModel;
+    if (needsModel)
+        card.summaryInstruction = SUMMARY_MODEL_INSTRUCTION;
+    else
+        delete card.summaryInstruction;
+    delete card.renderMarkdownTemplate;
+    delete card.renderHtml;
+    delete card.renderHtmlTemplate;
+    card.renderMarkdown = renderCardMarkdown(card, true);
+    updateItemSummary(normalized, card.index, summary, source, selectedFields, needsModel);
+}
+/** 同步摘要到索引条目（来源：Python update_item_summary，L3320）。
+ *
+ * V11.3 还会同步 `sessionMapPayload.items`；本实现在 `workflow.search` 里是
+ * **先补摘要、再 `saveListIndex`**，索引落盘的就是这份已原地改写的 `items`，语义等价。
+ */
+function updateItemSummary(normalized, index, summary, summarySource, fields, needsModel = false) {
+    const items = normalized.items;
+    if (!Array.isArray(items))
+        return;
+    for (const item of items) {
+        if (!item || typeof item !== 'object')
+            continue;
+        if (String(item.index) !== String(index))
+            continue;
+        item.cardSummary = summary;
+        item.summarySource = summarySource;
+        item.summaryFields = fields;
+        item.needsModelSummary = needsModel;
+        item.summaryContext = buildSummaryContextText(fields);
+        return;
+    }
+}
+/** 逐卡补摘要（来源：Python enrich_workflow_card_summaries，L3625）。
+ *
+ * 只为**当前页前 maxItems 张**卡片补详情，不为未展示页预取；并发上限 4 + 5s 短超时，单卡失败
+ * 只降级为该卡片的「摘要不可用」提示，不影响整条查询。
+ */
+async function enrichWorkflowCardSummaries(env, normalized, maxItems = 10) {
+    const cardItems = normalized.cardItems;
+    if (!Array.isArray(cardItems) || maxItems <= 0) {
+        normalized.summaryEnrichment = {
+            enabled: false,
+            reason: Array.isArray(cardItems) ? 'max_items_lte_zero' : 'no_card_items',
+        };
+        return normalized;
+    }
+    const targetCards = cardItems.slice(0, maxItems).filter((card) => card && typeof card === 'object');
+    // 会话只取一次（V11.3 把 runtime 传进每个 worker），避免 N 张卡重复解析登录态
+    const session = await env.host.getSession();
+    const userId = session.userId || undefined;
+    let completed = 0;
+    let unavailable = 0;
+    let detailsRequested = 0;
+    const errors = [];
+    const maxWorkers = Math.max(1, Math.min(targetCards.length, SUMMARY_ENRICH_MAX_WORKERS));
+    let cursor = 0;
+    const worker = async () => {
+        while (cursor < targetCards.length) {
+            const card = targetCards[cursor];
+            cursor += 1;
+            let result;
+            try {
+                result = await fetchCardSummaryResult(env, card, userId);
+            }
+            catch (error) {
+                result = {
+                    card: {},
+                    requested: true,
+                    summary: '详情接口异常，摘要暂不可用',
+                    source: 'workflowDetailUnavailable',
+                    fields: [],
+                    error: { stopReason: 'summary_worker_exception', error: errorText(error) },
+                };
+            }
+            if (result.requested)
+                detailsRequested += 1;
+            if (result.source === 'workflowDetailFormDataAutoSummary')
+                completed += 1;
+            else
+                unavailable += 1;
+            if (result.error && typeof result.error === 'object')
+                errors.push(result.error);
+            applyCardSummaryResult(normalized, result);
+        }
+    };
+    await Promise.all(Array.from({ length: maxWorkers }, () => worker()));
+    normalized.summaryEnrichment = {
+        enabled: true,
+        source: 'REQUEST_DETAIL',
+        requested: detailsRequested,
+        completed,
+        unavailable,
+        maxItems,
+        mode: 'parallel',
+        maxWorkers,
+        errors: errors.slice(0, 10),
+        rules: [
+            '列表接口 displayData 只提供流程系统字段；summaryContext 来自详情接口表单字段',
+            '最终卡片摘要已由命令根据表单业务字段生成，不混入发起人、发起时间、当前节点、流程状态、停留时长等辅助信息或流程元信息',
+            '每个卡片的 summaryForbiddenTerms 记录了发起人姓名等禁止进入摘要的词；脚本生成摘要时会过滤这些词',
+            '最终回复直接输出 renderMarkdown，不要重新生成摘要、不要重写模板结构、不要把 cardItems 改写成普通编号段落或连续纯文本',
+            '只为当前页卡片补摘要，不为未展示页预取详情',
+            '详情接口未返回表单数据时，只在对应卡片展示不可用提示，不使用系统字段伪造摘要',
+        ],
+    };
+    return normalized;
+}
 function normalizeDetailSummaryValue(_name, value) {
     let text = stripHtml(value);
     text = text.replace(/https?:\/\/\S+/gi, '').trim();
-    text = text.replace(/\s+/g, ' ').replace(/[：:;；,.，。]/g, '').trim();
-    if (text.length > 180)
-        text = text.slice(0, 180);
-    return text;
+    // 与 V11.3 一致：标点只裁**首尾**（Python `.strip(" ：:;；,.，。")`），不删正文里的标点——
+    // 旧实现用 `/[...]/g` 删掉了「金额：1000」这类值里的冒号，摘要读起来是「金额1000」。
+    text = text.replace(/\s+/g, ' ').replace(/^[ ：:;；,.，。]+|[ ：:;；,.，。]+$/g, '');
+    // 截断同样走 V11.3 的标点边界口径（旧实现是硬 slice，会把词截成半截）
+    return truncateText(text, 180);
 }
 function isMeaninglessSummaryValue(value) {
     const text = (value || '').trim();
@@ -3842,10 +4513,98 @@ function selectSummaryFields(fields, limit = 12) {
     }
     return candidates;
 }
-function generateBusinessSummary(fields) {
-    if (!fields.length)
-        return '该流程暂无可用表单数据，暂时无法生成摘要';
-    return fields.map((f) => `${f.fieldName}：${f.value}`).join('；');
+/** 业务摘要生成（来源：Python generate_business_summary，L1385）。
+ *
+ * 把任意工作流的表单字段归一为「原因 / 金额 / 类型 / 起止时间 / 时长 / 负责人」等通用语义角色，
+ * 按固定优先级拼成一句话（最多 3 个片段、总长 100 字内），**不依赖具体流程模板**。语义角色凑不齐
+ * 时用尚未使用的业务字段兜底补齐。信息量不足（< `SUMMARY_MODEL_FALLBACK_MIN_LEN`）时返回空串，
+ * 由调用方标记 `needsModelSummary` 交模型基于 `summaryContext` 理解生成。
+ *
+ * `forbiddenTerms` 是发起人姓名等禁止进入摘要的词（见 `listSummaryForbiddenTerms`）。
+ */
+function generateBusinessSummary(fields, forbiddenTerms = null) {
+    const cleanFields = [];
+    for (const field of fields) {
+        const name = stripHtml(field?.fieldName ?? '');
+        const value = stripHtml(field?.value ?? '');
+        if (!name || !value)
+            continue;
+        if ((forbiddenTerms ?? []).some((term) => stripHtml(term) && value.includes(stripHtml(term))))
+            continue;
+        cleanFields.push({ fieldName: name, value, componentKey: asString(field?.componentKey) ?? '' });
+    }
+    if (!cleanFields.length)
+        return '';
+    const reasonCandidates = bestReasonFields(cleanFields);
+    let reasonField = reasonCandidates.length ? reasonCandidates[0] : null;
+    const anchorStem = reasonField ? summaryFieldStem(reasonField.fieldName) : '';
+    const amountField = bestSemanticField(cleanFields, 'amount', anchorStem);
+    const typeField = bestSemanticField(cleanFields, 'type', anchorStem);
+    const durationField = bestSemanticField(cleanFields, 'duration', anchorStem);
+    const personField = bestSemanticField(cleanFields, 'person', anchorStem);
+    const temporalFragment = summaryTemporalFragment(cleanFields, anchorStem);
+    const fragments = [];
+    const usedPairs = new Set();
+    const pairKey = (field) => `${stripHtml(field?.fieldName)}\u0000${stripHtml(field?.value)}`;
+    const appendFragment = (text, field) => {
+        const value = stripHtml(text);
+        if (!value || fragments.length >= 3)
+            return;
+        let pair = null;
+        if (field) {
+            pair = pairKey(field);
+            if (usedPairs.has(pair))
+                return;
+        }
+        if (fragments.includes(value))
+            return;
+        fragments.push(value);
+        if (pair)
+            usedPairs.add(pair);
+    };
+    let reasonText = '';
+    let reasonScore = 0;
+    if (reasonField) {
+        reasonScore = scoreSummaryFieldValue(stripHtml(reasonField.fieldName), stripHtml(reasonField.value));
+        reasonText = summarizeReasonText(extractLabeledSummaryValue(stripHtml(reasonField.value)));
+        // 主字段提炼后过短（< 8 字）→ 顺延到信息量次高的描述字段
+        if (reasonText.length < 8) {
+            for (const alternative of reasonCandidates.slice(1)) {
+                const alternativeText = summarizeReasonText(extractLabeledSummaryValue(stripHtml(alternative.value)));
+                if (alternativeText.length > reasonText.length) {
+                    reasonField = alternative;
+                    reasonText = alternativeText;
+                    reasonScore = scoreSummaryFieldValue(stripHtml(alternative.fieldName), stripHtml(alternative.value));
+                    break;
+                }
+            }
+        }
+    }
+    if (reasonText && reasonScore >= 4)
+        appendFragment(reasonText, reasonField);
+    if (amountField)
+        appendFragment(`${stripHtml(amountField.fieldName)}${valueWithUnit(stripHtml(amountField.value), '元')}`, amountField);
+    if (typeField)
+        appendFragment(`${stripHtml(typeField.fieldName)}${stripHtml(typeField.value)}`, typeField);
+    appendFragment(temporalFragment);
+    if (durationField)
+        appendFragment(`${stripHtml(durationField.fieldName)}${stripHtml(durationField.value)}`, durationField);
+    if (reasonText && reasonScore < 4) {
+        appendFragment(reasonField ? `${stripHtml(reasonField.fieldName)}${reasonText}` : reasonText, reasonField);
+    }
+    if (personField)
+        appendFragment(`${stripHtml(personField.fieldName)}${stripHtml(personField.value)}`, personField);
+    // 语义角色仍不足时，用尚未使用的业务字段补齐（通用兜底，不按工作流写特例）
+    for (const field of cleanFields) {
+        if (usedPairs.has(`${field.fieldName}\u0000${field.value}`))
+            continue;
+        if (field.value && fragments.some((fragment) => fragment.includes(field.value)))
+            continue;
+        appendFragment(`${field.fieldName}${field.value}`, field);
+        if (fragments.length >= 3)
+            break;
+    }
+    return cleanGeneratedSummary(fragments.join('，'), forbiddenTerms, 100, false);
 }
 // ---------------------------------------------------------------------------
 // workflow.open（来源：cmd_workflow_open / build_workflow_open_url）