weaver-work-cli 0.1.8 → 0.1.21

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

@@ -8,7 +8,7 @@
 // （saveSearchIndex / findIndexedItem，由 CLI 托管，本文件不读写索引文件）；
 // 查看/操作类 operation 允许用 requestId 或 group+index 定位（findIndexedItem）。
 import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CATEGORY, SCHEMA_INDEX, SCHEMA_PAGE_SIZE, } from './types.js';
-import { asString, asInt, asStringArray, asBool, compact, responseData, detailDataOf, toArray, resolveMemoryAppId, withLeadingMeta, STDOUT_SAFE_BYTES, stdoutBytesOf, } from './shared.js';
+import { asString, asInt, asStringArray, asBool, compact, responseData, detailDataOf, toArray, resolveMemoryAppId, withLeadingMeta, STDOUT_SAFE_BYTES, stdoutBytesOf, parseNameWithId, } from './shared.js';
 import { workflowValidationError, WorkflowCliError, workflowClarificationError, CLARIFICATION_SUBTYPE, } from '../errors.js';
 import { WORKFLOW_ENDPOINTS } from '../endpoints.js';
 import { loadSearchIndex, saveSearchIndex, findIndexedItem, readStateFile, writeStateFileBestEffort, } from '../state.js';
@@ -225,21 +225,6 @@ function cardWorkflowOpenUrl(card, baseUrl) {
         ? `${base}?secondEmpId=${encodeURIComponent(userMasterId)}&requestId=${encodeURIComponent(requestId)}`
         : base;
 }
-/** 解析 "名称(ID)" 或纯 ID / 纯名称 → (name, id)。ID 必须是纯数字才认定为 ID。 */
-function parseNameWithId(value) {
-    const text = (value || '').trim();
-    if (!text)
-        return { name: '' };
-    const match = /^(.+?)[（(]([^（）()]*)[)）]\s*$/.exec(text);
-    if (match) {
-        const name = match[1].trim();
-        const idPart = match[2].trim();
-        if (name && idPart && /^[0-9]+$/.test(idPart)) {
-            return { name, id: idPart };
-        }
-    }
-    return { name: text };
-}
 function splitCsv(value) {
     if (value === undefined || value === null)
         return [];
@@ -1178,7 +1163,61 @@ function isActionableRemark(value) {
         return false;
     return Number(text) < 100;
 }
-function normalizeListResponse(response, category, categoryName, baseUrl = '') {
+/**
+ * `isremark` 码位 → **当前用户在该节点上的参与身份名称**（列表卡片用）。
+ *
+ * 为什么需要本地映射：**待办列表接口（`getTodoListData`）的原始记录只有数字 `isremark`
+ * （外加 `isremarktype` 等辅助位），没有身份名称**（2026-09-20 用 fetch 探针抓原始响应确认：
+ * 一行 100+ 字段里只有 `isremark = 0`）。而分组计数接口（`getTodoGroupCount`，即 todoStat）
+ * **会返回 `isRemarkName`** —— 本表就是按那套名称词表建的。
+ *
+ * 码位语义来源：V11.3 `scripts/e10_workflow.py` 的 `is_actionable_remark` 注释（逐条对齐）——
+ *   `0/1` 正常提交、`10/11` 意见征询（走 consulReply）、`20/21` 传阅需批示、`30/31` 抄送需提交、
+ *   `40/41` 转发需批注、`60/61` 传阅不需批示、`70/71` 抄送不需提交、`80/81` 转发不需批注；
+ *   **尾位 +1 即「(委托)」变体**（V11.3 全部以 `n/n+1` 成对书写）；`100` 不可操作（非身份）。
+ * 名称词表来源：V11.3 `references/workflow-search.md`「参与身份说明」的 20 条身份，并与真机
+ * `isRemarkName` 实测值逐条一致（本租户 2026-09-20 实测：`0`=节点操作者、`30`=抄送接收人、
+ *   `40`=转发接收人、`70`=抄送接收人不需反馈）。
+ *
+ * ⚠️ **只覆盖有据可查的码位**：「超时指定干预人」「异常处理指定干预人」两族身份的码位在
+ * V11.3 注释与实测里都没有出现，**不猜**——**未覆盖的码位一律返回空串**（模型据此不得臆断身份，
+ * 需要身份时以 todoStat 的 `isRemarkName` 为准）。
+ */
+const REMARK_IDENTITY_NAMES = {
+    '0': '节点操作者',
+    '1': '节点操作者(委托)',
+    '10': '意见征询接收人',
+    '11': '意见征询接收人(委托)',
+    '20': '传阅接收人',
+    '21': '传阅接收人(委托)',
+    '30': '抄送接收人',
+    '31': '抄送接收人(委托)',
+    '40': '转发接收人',
+    '41': '转发接收人(委托)',
+    '60': '传阅接收人不需反馈',
+    '61': '传阅接收人不需反馈(委托)',
+    '70': '抄送接收人不需反馈',
+    '71': '抄送接收人不需反馈(委托)',
+    '80': '转发接收人不需反馈',
+    '81': '转发接收人不需反馈(委托)',
+};
+/** 取参与身份名称：优先用服务端下发的名称（若该接口将来下发），否则按码位表映射；未覆盖码位返回空串 */
+function remarkIdentityName(rawName, remarkValue) {
+    const fromServer = asString(rawName) ?? '';
+    if (fromServer)
+        return fromServer;
+    const text = remarkValue === undefined || remarkValue === null ? '' : String(remarkValue).trim();
+    if (!/^-?\d+$/.test(text))
+        return '';
+    return REMARK_IDENTITY_NAMES[String(Number(text))] ?? '';
+}
+/** 列表响应归一化（来源：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 ?? []);
@@ -1214,6 +1253,9 @@ function normalizeListResponse(response, category, categoryName, baseUrl = '') {
             flowStatus,
             requestMark: pickText(recordObj, 'requestmark', 'requestMark', 'requestCode'),
             isRemark: isRemarkRaw === undefined || isRemarkRaw === null ? '' : String(isRemarkRaw).trim(),
+            // 参与身份名称：列表接口原始记录没有该字段 ⇒ 按 isremark 码位本地映射（映射出处见
+            // REMARK_IDENTITY_NAMES）；若将来服务端在该接口下发 `isremarkname`，以服务端值为准。
+            isRemarkName: remarkIdentityName(pickText(recordObj, 'isremarkname', 'isRemarkName'), isRemarkRaw),
             canSubmitRejectTransfer: isActionableRemark(isRemarkRaw),
             stayStartAt,
             stayDuration: category === 'todo' ? humanizeDurationSince(stayStartAt) : '',
@@ -1225,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;
     });
@@ -1247,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,
@@ -1269,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;
         }),
     };
@@ -1302,6 +1354,7 @@ const SLIM_INDEX_ITEM_KEYS = [
     'workflowName',
     'canSubmitRejectTransfer',
     'isRemark',
+    'isRemarkName',
     'finished',
     'overdue',
 ];
@@ -1480,7 +1533,6 @@ const workflowSearch = {
         pageSize: SCHEMA_PAGE_SIZE,
         conditionType: { type: 'string', enum: ['and', 'or'], default: 'and' },
         totalOnly: { type: 'boolean', default: false },
-        mode: { type: 'string', enum: ['auto', 'legacy', 'smart'], default: 'auto', description: '执行模式强制覆盖，仅回归验证用；默认按 OA 版本自动路由' },
         batchType: {
             type: 'string',
             enum: ['submit', 'urge', 'read', 'share', 'forward', 'reject'],
@@ -1494,16 +1546,18 @@ const workflowSearch = {
         if (plan && typeof plan === 'object') {
             // plan 批量编排仅智能分组模式支持（来源：Python cmd_workflow_search_plan 首行的
             // resolve_workflow_search_mode 门禁）——该模式下 todoStat 的统计口径才成立；低版本 OA 上
-            // 直接拒绝，并引导改用单条查询，避免静默按错口径分组。--mode smart 仍可强制（回归验证用）。
-            const planMode = await resolveSearchMode(env, args);
+            // 直接拒绝，并引导改用单条查询，避免静默按错口径分组。
+            // 门禁与 memoryPrompt 的 oaContext.smartGrouping 同源（同一常量 + 同一比较函数），并且**没有
+            // 强制覆盖开关**：模型拿到的布尔值就是这里的判据，不会出现「模型以为能用、这里却拒绝」的错位。
+            const planMode = await resolveSearchMode(env);
             if (planMode !== 'smart') {
-                throw workflowValidationError('plan_requires_smart_mode', `plan 批量编排模式仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请改用单条 workflow.search`, { retryAllowed: false, renderMode: planMode });
+                throw workflowValidationError('plan_requires_smart_mode', `plan 批量编排模式仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请改用单条 workflow.search`, { retryAllowed: false });
             }
             // 顶层 pageSize 即 plan 的展示窗口 page_cap（来源：Python cmd_workflow_search_plan 的 page_cap）
             return executePlanSearch(env, plan, asInt(args.pageSize) ?? 10);
         }
         const category = (asString(args.category) || 'todo');
-        const searchMode = await resolveSearchMode(env, args);
+        const searchMode = await resolveSearchMode(env);
         const batchType = asString(args.batchType);
         const totalOnly = asBool(args.totalOnly, false);
         // legacy 待办查询走 CLI 侧分组（V11.2 语义；来源：Python execute_workflow_search_legacy 的
@@ -1576,19 +1630,28 @@ const workflowSearch = {
         if (totalOnly) {
             return workflowSuccess('workflow.search', {
                 type: 'workflowSearch',
-                renderMode: searchMode,
                 category,
                 categoryName: CATEGORY_NAMES[category],
                 total,
                 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',
-            renderMode: searchMode,
             category,
             categoryName: CATEGORY_NAMES[category],
             total,
@@ -1598,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' }));
@@ -1629,11 +1692,13 @@ function isVersionAtLeast(actual, min) {
     }
     return true;
 }
-/** 解析查询执行模式：版本 ≥ 基线走 smart；版本未知/运行时不可用 → legacy 兜底 */
-async function resolveSearchMode(env, args) {
-    const forced = (asString(args.mode) ?? '').toLowerCase();
-    if (forced === 'smart' || forced === 'legacy')
-        return forced;
+/**
+ * 解析查询执行模式：版本 ≥ 基线走 smart；版本未知/运行时不可用 → legacy 兜底。
+ * **不接受任何参数强制覆盖**——与 `memoryPrompt` 的 `oaContext.smartGrouping` 完全同源（同一常量 +
+ * 同一比较函数），这样模型读到的布尔值与服务端门禁不可能漂移。
+ * （09-21 用户裁定移除 `mode` 强制开关：它只是临时调试用，暴露出去反而会诱导模型「试一试」。）
+ */
+async function resolveSearchMode(env) {
     try {
         const session = await env.host.getSession();
         const version = asString(session.version) ?? '';
@@ -1663,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) {
@@ -1686,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');
@@ -1757,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）。 */
@@ -1825,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;
@@ -1911,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);
@@ -1983,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 = {};
@@ -2037,7 +2116,6 @@ async function executeLegacyGroupedTodoSearch(env, args) {
         .join('\n\n');
     return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
         type: 'workflowSearch',
-        renderMode: 'legacy',
         category: 'todo',
         categoryName: CATEGORY_NAMES.todo,
         displayMode: 'groupedCards',
@@ -2149,11 +2227,17 @@ function extractTotal(response) {
     }
     return null;
 }
-/** 单张卡片的三行 Markdown：标题行（含徽标）+ 元信息行（来源：Python render_card_markdown）。
+/** 单张卡片的 Markdown：标题行（含徽标）+ **可选**摘要行 + 元信息行（来源：Python render_card_markdown）。
  *
- * smart（智能分组）模式不渲染摘要行——与 Python `include_summary=False` 一致。
+ * `includeSummary` 决定是否渲染摘要行（第 2 行）——**契约**见 `references/workflow-query.md`
+ * 「执行模式与返回形态」的「卡片摘要行」一行：
+ * - `true`（legacy / 低版本模式）→ **标题/摘要/辅助三行**，摘要由 `enrichWorkflowCardSummaries`
+ *   逐卡补详情（REQUEST_DETAIL）后生成；
+ * - `false`（smart / 智能分组模式，以及 `batchType` 批量取数）→ **标题/辅助两行**。
+ *
+ * 默认 `false`：避免未经富化的卡片被渲染出一行占位摘要（`batchType` 与 plan 卡片都不补摘要）。
  */
-function renderCardMarkdown(card) {
+function renderCardMarkdown(card, includeSummary = false) {
     const badgeTexts = (card.badgeObjects || [])
         .map((badge) => stripHtml(badge?.text))
         .filter(Boolean)
@@ -2171,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）
@@ -2883,9 +2977,9 @@ const workflowTodoStat = {
         // 来源：Python 无独立 todoStat operation，只有 cmd_workflow_search_plan 的 smart 门禁 +
         // execute_workflow_search_legacy 的分组输出——低版本待办统计由 workflow.search 的 legacy 分组输出承担。
         // 低版本直接拒绝，避免模型拿到"全部(0)"口径统计（与 legacy"待处理(7)"口径矛盾）后按错误口径规划分组。
-        const mode = await resolveSearchMode(env, args);
+        const mode = await resolveSearchMode(env);
         if (mode !== 'smart') {
-            throw workflowValidationError('todo_stat_requires_smart_mode', `workflow.todoStat 仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请直接走 workflow.search（CLI 会自动输出分组统计）`, { retryAllowed: false, renderMode: mode });
+            throw workflowValidationError('todo_stat_requires_smart_mode', `workflow.todoStat 仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请直接走 workflow.search（CLI 会自动输出分组统计）`, { retryAllowed: false });
         }
         const { query } = await buildSearchQuery(env, { ...args, category: 'todo' }, 'stat');
         const response = await env.host.workflowRequest({
@@ -2983,7 +3077,7 @@ const workflowDetail = {
                 '表单内容区只展示核心业务字段，跳过空值、技术字段、可编辑、操作按钮、岗位、部门、最后反馈时间等非必要字段',
                 '表单字段值必须原样展示 value，不能摘要、改写、删减；字段含 valueHtml/links 时优先渲染为可点击超链接，不要把长 URL 直接作为普通文本换行展示',
                 'displayMode=longTextBlock 或 fullWidth=true 的表单字段必须全宽展示，保留原文、标点和换行；不要保留接口富文本里的背景色、字号和大段空白',
-                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按三行展示（操作人/方式/时间、接收人、签字意见内容）',
+                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按两行展示（操作人/方式/时间、签字意见内容）',
                 '签字意见区标题写成「签字意见（{{paginationText}}）」；只有 requestLog.hasMore=true 时才显示 nextPagePrompt',
                 '不要展示 requestId；不要展示 workflowName，用户明确询问所属工作流时才展示为「工作流名称」；不要翻译、音译或改写接口返回文本',
                 '详情面板后不要输出固定建议列表或「如果想进一步操作」类尾巴；用户要求摘要/总结时改为围绕表单业务内容提炼，不要渲染详情表',
@@ -3043,7 +3137,7 @@ function normalizeDetailResponse(response) {
         warnings.push('接口未返回该流程的任何详情内容（流程标题/编号/发起人/发起时间/当前节点/表单字段全为空）。'
             + '这不代表"流程是空的"，也不代表流程一定不存在——最可能是这个 requestId 在本环境查不到对应流程'
             + '（编号抄错、来自其他环境、已被删除）。'
-            + '请先用 `workflow.search` / `workflow.createList` 在本环境确认该流程可见、并直接从那一次的'
+            + '请先用 `workflow.search` 在本环境确认该流程可见、并直接从那一次的'
             + '`cards[].requestId` 取值，再重试；若确认流程存在却仍取不到，请如实告知用户"详情不可见"，'
             + '不要编造流程内容。');
     }
@@ -3204,19 +3298,14 @@ function extractFormFields(data) {
 // V12 早期版本把"递归"退化成"枚举 4 条固定路径"（`data.list` / `data.records` …），而
 // `getRequestLog` 的真实响应是 `{message:{errcode,errmsg}, data:[…]}` —— **`data` 直接是数组**
 // ⇒ 四条路径全 miss ⇒ 签字意见恒为空。真机探针实测同一份响应：V11.3 解出 8 条、V12 解出 0 条。
-// 归一化侧的 `display_text_from_value` 一族（对象取值 / 用户名映射 / 时间戳格式化 / 接收人解析）
-// V12 同样缺失 ⇒ 一并补齐。
+// 归一化侧的 `display_text_from_value` 一族（对象取值 / 时间戳格式化）V12 同样缺失 ⇒ 一并补齐。
+// （接收人解析链已于 2026-09-20 按要求整体删除，不再取 `receivedPersonIds` / `userDataMap`。）
 // ---------------------------------------------------------------------------
 /** 展示文本候选键（来源：V11.3 `DISPLAY_TEXT_KEYS`）。 */
 const LOG_DISPLAY_TEXT_KEYS = [
     'showValue', 'displayValue', 'name', 'showName', 'lastName', 'lastname', 'userName',
     'username', 'label', 'title', 'text', 'content', 'value',
 ];
-/** 用户 ID 候选键（来源：V11.3 `USER_ID_KEYS`）。 */
-const LOG_USER_ID_KEYS = [
-    'id', 'userId', 'userid', 'uid', 'resourceId', 'resourceid', 'masterId', 'masterid',
-    'identityId', 'identityid',
-];
 /** 日志容器候选键（来源：V11.3 `collect_detail_logs_from_obj`）。 */
 const LOG_CONTAINER_KEYS = [
     'requestLogList', 'requestLogs', 'logs', 'logList', 'operatorList', 'signList', 'remarkList',
@@ -3253,13 +3342,6 @@ const LOG_OPINION_KEYS = [
     'opinion', 'remark', 'remarks', 'signRemark', 'signremark', 'content', 'comment', 'message',
     'requestLogContent', 'commentContent', 'commentcontent',
 ];
-const LOG_RECEIVER_ID_KEYS = [
-    'receivedPersonIds', 'receivedpersonids', 'receivedPersonId', 'receivePersonIds', 'receiverIds',
-    'recipientIds',
-];
-const LOG_RECEIVER_TEXT_KEYS = [
-    'receivedPersons', 'receivedPersonNames', 'receiverNames', 'receivers', 'recipients',
-];
 /** 宽松取键：先精确匹配、再忽略大小写（来源：V11.3 `pick_raw`）。 */
 function pickRawLoose(source, ...keys) {
     if (!source || typeof source !== 'object' || Array.isArray(source))
@@ -3301,8 +3383,8 @@ function displayTextFromValue(value, depth = 0) {
         const record = value;
         if (Object.keys(record).length === 0)
             return '';
-        // ★ 必须走 `pickRawLoose`（大小写不敏感）：实测 `userDataMap` 的键是 `UserName`（大写 U+N），
-        // 而候选键写的是 `userName`/`username` —— 用 `in` 精确匹配会取不到，接收人就只能显示裸 ID。
+        // ★ 必须走 `pickRawLoose`（大小写不敏感）：实测服务端回的对象键常与候选键大小写不一致
+        // （如 `UserName` 对上候选键 `userName`）—— 用 `in` 精确匹配会取不到值。
         for (const key of LOG_DISPLAY_TEXT_KEYS) {
             const raw = pickRawLoose(record, key);
             if (raw === undefined)
@@ -3332,125 +3414,6 @@ function pickDisplayText(source, ...keys) {
     }
     return '';
 }
-/** 值 → 去重 ID 列表（来源：V11.3 `value_to_id_list`，ID 串按 `,，;；空白` 切分）。 */
-function valueToIdList(value) {
-    const ids = [];
-    const pushText = (text) => {
-        for (const part of stripHtml(text).split(/[,，;；\s]+/u)) {
-            if (part)
-                ids.push(part);
-        }
-    };
-    const push = (input) => {
-        if (input === null || input === undefined)
-            return;
-        if (Array.isArray(input)) {
-            input.forEach(push);
-            return;
-        }
-        if (typeof input === 'object') {
-            const record = input;
-            for (const key of [...LOG_USER_ID_KEYS, 'value']) {
-                const raw = pickRawLoose(record, key);
-                if (raw !== null && raw !== undefined && raw !== '') {
-                    push(raw);
-                    return;
-                }
-            }
-            return;
-        }
-        pushText(String(input));
-    };
-    push(value);
-    return [...new Set(ids)];
-}
-/** 用户映射里按 id 查姓名（来源：V11.3 `user_name_from_map`）。 */
-function userNameFromMap(map, userId) {
-    if (!map || !userId)
-        return '';
-    const direct = displayTextFromValue(map[userId]);
-    if (direct)
-        return direct;
-    for (const [key, candidate] of Object.entries(map)) {
-        if (String(key) === String(userId)) {
-            const text = displayTextFromValue(candidate);
-            if (text)
-                return text;
-        }
-        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate))
-            continue;
-        const candidateIds = LOG_USER_ID_KEYS.flatMap((idKey) => valueToIdList(pickRawLoose(candidate, idKey)));
-        if (candidateIds.some((id) => String(id) === String(userId))) {
-            const text = displayTextFromValue(candidate);
-            if (text)
-                return text;
-        }
-    }
-    return '';
-}
-/**
- * 收集 `userDataMap` 并建 `id → 用户对象` 索引
- * （来源：V11.3 `extract_user_data_map` / `normalize_user_data_map` / `add_user_map_item`）。
- *
- * 真机实测：`getRequestLog` 的 `userDataMap`（`[{UserName, userId}, …]`，90+ 条）挂在**每条日志项内部**
- * 而不是响应顶层 ⇒ 除了遍历响应，还要逐项收一遍，否则接收人只能显示裸 ID。
- */
-function collectUserDataMap(source) {
-    const mapped = {};
-    const addItem = (item, fallbackKey) => {
-        if (fallbackKey !== undefined && fallbackKey !== '')
-            mapped[String(fallbackKey)] = item;
-        if (!item || typeof item !== 'object' || Array.isArray(item))
-            return;
-        const record = item;
-        for (const key of LOG_USER_ID_KEYS) {
-            const rawId = pickRawLoose(record, key);
-            if (rawId !== null && rawId !== undefined && rawId !== '')
-                mapped[String(rawId)] = item;
-        }
-        for (const nestedKey of ['user', 'userInfo', 'userBaseInfo', 'resource', 'resourceInfo', 'hrmResource', 'person', 'identity']) {
-            const nested = record[nestedKey];
-            if (nested && typeof nested === 'object' && !Array.isArray(nested))
-                addItem(nested);
-        }
-    };
-    const addMapLike = (value) => {
-        if (Array.isArray(value)) {
-            value.forEach((item) => addItem(item));
-            return;
-        }
-        if (value && typeof value === 'object') {
-            for (const [key, item] of Object.entries(value)) {
-                if (Array.isArray(item))
-                    item.forEach((nested) => addItem(nested));
-                else
-                    addItem(item, key);
-            }
-        }
-    };
-    const walk = (value, depth = 0) => {
-        if (!value || typeof value !== 'object' || depth > 2)
-            return;
-        if (Array.isArray(value)) {
-            value.forEach((item) => {
-                if (item && typeof item === 'object') {
-                    const direct = pickRawLoose(item, 'userDataMap', 'userdataMap', 'userMap', 'userInfoMap', 'resourceDataMap');
-                    if (direct !== undefined)
-                        addMapLike(direct);
-                }
-            });
-            return;
-        }
-        const record = value;
-        const direct = pickRawLoose(record, 'userDataMap', 'userdataMap', 'userMap', 'userInfoMap', 'resourceDataMap');
-        if (direct !== undefined)
-            addMapLike(direct);
-        for (const nestedKey of ['data', 'result', 'payload'])
-            walk(record[nestedKey], depth + 1);
-    };
-    walk(source);
-    return mapped;
-}
 /** 数字串 → 本地可读时间（`YYYY-MM-DD HH:mm:ss`）。 */
 function formatLogTimestamp(ms) {
     const date = new Date(ms);
@@ -3479,26 +3442,18 @@ function stripWeaverMteTokens(text) {
         return text;
     return text.replace(/_weaverMte_\S+/gu, ' ').replace(/\s+/gu, ' ').trim();
 }
-/** 接收人（ID 列表 + 显示串）。来源：V11.3 `resolve_received_persons`。 */
-function resolveReceivedPersons(item, userDataMap) {
-    const ids = valueToIdList(pickRawLoose(item, ...LOG_RECEIVER_ID_KEYS));
-    let display = ids.map((id) => userNameFromMap(userDataMap, id) || id).join('、');
-    if (!display)
-        display = pickDisplayText(item, ...LOG_RECEIVER_TEXT_KEYS);
-    return { ids, display };
-}
 /**
  * 递归收集日志条目（来源：V11.3 `collect_detail_logs_from_obj`）。
  *
  * ★ 关键在"递归"：`data` 可能是数组、也可能是对象里某个键下面挂着数组。V12 早期只枚举四条固定路径，
  * 遇到 `getRequestLog` 的"`data` 是数组"形态就整条归零。
  */
-function collectDetailLogsFromObj(obj, logs, userDataMap, limit) {
+function collectDetailLogsFromObj(obj, logs, limit) {
     if (logs.length >= limit)
         return;
     if (Array.isArray(obj)) {
         for (const item of obj) {
-            collectDetailLogsFromObj(item, logs, userDataMap, limit);
+            collectDetailLogsFromObj(item, logs, limit);
             if (logs.length >= limit)
                 break;
         }
@@ -3507,19 +3462,19 @@ function collectDetailLogsFromObj(obj, logs, userDataMap, limit) {
     if (!obj || typeof obj !== 'object')
         return;
     const record = obj;
-    const normalized = normalizeLogItem(record, userDataMap);
+    const normalized = normalizeLogItem(record);
     if (detailLogHasContent(normalized))
         logs.push(normalized);
     for (const key of LOG_CONTAINER_KEYS) {
         if (key in record)
-            collectDetailLogsFromObj(record[key], logs, userDataMap, limit);
+            collectDetailLogsFromObj(record[key], logs, limit);
     }
 }
 /**
  * 从接口响应里取出签字意见条目（来源：V11.3 `extract_request_log_items`）。
  *
  * 取 `response.data` 作为源（为空则回退整个 response），递归收集后按
- * `node/operator/time/action/receivers/opinion` 六元组去重。
+ * `node/operator/time/action/opinion` 五元组去重。
  */
 function extractRequestLogItems(response, limit = 500) {
     const wrapper = response && typeof response === 'object' && !Array.isArray(response)
@@ -3531,13 +3486,12 @@ function extractRequestLogItems(response, limit = 500) {
         || (typeof source === 'object' && !Array.isArray(source) && Object.keys(source).length === 0);
     if (emptySource)
         source = response;
-    const userDataMap = collectUserDataMap(response);
     const logs = [];
-    collectDetailLogsFromObj(source, logs, userDataMap, limit);
+    collectDetailLogsFromObj(source, logs, limit);
     const seen = new Set();
     const unique = [];
     for (const log of logs) {
-        const key = [log.node, log.operator, log.time, log.action, log.receivers, log.opinion]
+        const key = [log.node, log.operator, log.time, log.action, log.opinion]
             .map((part) => String(part ?? ''))
             .join('\u0001');
         if (seen.has(key))
@@ -3554,7 +3508,6 @@ function extractRequestLogItems(response, limit = 500) {
 function extractRequestLogs(data) {
     if (!data || typeof data !== 'object')
         return [];
-    const userDataMap = collectUserDataMap(data);
     const logs = [];
     for (const [key, value] of Object.entries(data)) {
         if (!LOG_CONTAINER_KEY_PATTERN.test(key))
@@ -3563,12 +3516,12 @@ function extractRequestLogs(data) {
             continue;
         if (Array.isArray(value) && value.length === 0)
             continue;
-        collectDetailLogsFromObj(value, logs, userDataMap, 40);
+        collectDetailLogsFromObj(value, logs, 40);
     }
     return logs;
 }
 function detailLogHasContent(log) {
-    return Boolean(log && (log.node || log.operator || log.action || log.time || log.opinion || log.receivers));
+    return Boolean(log && (log.node || log.operator || log.action || log.time || log.opinion));
 }
 // ---------------------------------------------------------------------------
 // 签字意见归一化（来源：normalize_detail_log_item / fetch_request_log_page）
@@ -3656,17 +3609,17 @@ async function fetchRequestLogPage(env, requestId, current, pageSize) {
 /**
  * 签字意见单条归一化（来源：V11.3 `normalize_detail_log_item`）。
  *
- * 三处「V11.3 有、V12 缺」的处理，缺一个就会显示成空白或乱码：
+ * 两处「V11.3 有、V12 缺」的处理，缺一个就会显示成空白或乱码：
  * ① **操作人取 `commentor`** —— 真机实测该字段是**对象**（`{id, name:'孙一一', username}`），
  *    必须走 `displayTextFromValue`；旧写法用 `pickText` 只会把对象 `String()` 成 `[object Object]`。
  * ② **时间走 `normalizeLogTimeText`** —— 接口给的是 **毫秒时间戳**（`1743082059000`）。
- * ③ **接收人走 `resolveReceivedPersons`** —— `receivedPersonIds`（id 串）+ `userDataMap`（id→姓名）解析；
- *    实测某条签字意见的接收人有 90+ 人，不解析就只能显示一串裸 ID。
+ *
+ * 接收人（`receivedPersonIds` + `userDataMap` 解析）已按要求整体移除：解析链（`resolveReceivedPersons` /
+ * `userNameFromMap` / `collectUserDataMap` / `valueToIdList` 与 `LOG_RECEIVER_*_KEYS`）一并删除。
  */
-function normalizeLogItem(item, userDataMap = {}) {
+function normalizeLogItem(item) {
     if (!item || typeof item !== 'object')
         return {};
-    const mergedMap = { ...userDataMap, ...collectUserDataMap(item) };
     let node = pickDisplayText(item, ...LOG_NODE_KEYS);
     if (/^\d{12,}$/u.test(stripHtml(node)))
         node = '';
@@ -3675,7 +3628,6 @@ function normalizeLogItem(item, userDataMap = {}) {
     const time = normalizeLogTimeText(pickDisplayText(item, ...LOG_TIME_KEYS));
     const action = pickDisplayText(item, ...LOG_ACTION_KEYS);
     const opinion = stripWeaverMteTokens(pickDisplayText(item, ...LOG_OPINION_KEYS));
-    const receivers = resolveReceivedPersons(item, mergedMap);
     const operatorDisplay = operator || '未返回';
     const actionDisplay = action || '未返回';
     const timeDisplay = time || '未返回';
@@ -3690,17 +3642,13 @@ function normalizeLogItem(item, userDataMap = {}) {
         actionDisplay,
         operatorAction: `${operatorDisplay} · ${actionDisplay}`,
         operatorActionTime: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
-        receiverIds: receivers.ids,
-        receivers: receivers.display,
-        receiverDisplay: receivers.display || '未返回',
         opinion,
         opinionDisplay,
         displayLines: {
             line1: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
-            line2: `接收人：${receivers.display || '未返回'}`,
             line3: opinionDisplay,
         },
-        displayLayout: 'threeLineSignatureOpinion',
+        displayLayout: 'twoLineSignatureOpinion',
     };
 }
 /** 详情字段取值：有 links 时优先渲染为可点击超链接（来源：Python detail_field_markdown_value） */
@@ -3766,7 +3714,6 @@ function renderDetailMarkdown(normalized) {
         for (const it of logItems) {
             const dl = it.displayLines || {};
             let line1 = asString(dl.line1) ?? '';
-            let line2 = asString(dl.line2) ?? '';
             let line3 = asString(dl.line3) ?? '';
             if (!line1) {
                 const operator = asString(it.operatorDisplay) ?? '未返回';
@@ -3774,13 +3721,11 @@ function renderDetailMarkdown(normalized) {
                 const timeText = asString(it.timeDisplay) ?? asString(it.createdAt) ?? '未返回';
                 line1 = `${operator} · ${action} · ${timeText}`;
             }
-            if (!line2)
-                line2 = `接收人：${asString(it.receiverDisplay) ?? '未返回'}`;
             if (!line3) {
                 const opinion = asString(it.opinionDisplay) ?? asString(it.contentDisplay) ?? asString(it.content) ?? '未填写意见';
                 line3 = `签字意见：${opinion}`;
             }
-            lines.push(`> **${line1}**`, '>', `> ${line2}`, '>', `> ${line3}`, '>');
+            lines.push(`> **${line1}**`, '>', `> ${line3}`, '>');
         }
         if (lines[lines.length - 1] === '>')
             lines.pop();
@@ -3868,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();
@@ -3954,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）
@@ -4192,8 +4839,8 @@ const workflowMemoryPrompt = {
         };
         if (!result.available)
             result.diagnosis = { code: body?.code, status: body?.status, fail: body?.fail, dataEmpty: !promptText };
-        // oaContext：OA 版本 + 当前用户身份（岗位/部门/分部）。原 Python 由登录技能 whoami
-        // 提供；CLI 侧等价信息由会话自身承载，无需额外请求。
+        // oaContext：OA 版本 + 当前用户身份（岗位/部门/分部）。原 Python 由旧登录链路
+        // 的 whoami 提供；CLI 侧等价信息由会话自身承载，无需额外请求。
         const session = await env.host.getSession();
         const user = {};
         const userCandidates = [
@@ -4213,7 +4860,14 @@ const workflowMemoryPrompt = {
             oaContext.version = version;
         if (Object.keys(user).length)
             oaContext.user = user;
-        const hasOaContext = Object.keys(oaContext).length > 0;
+        // ★ 当前环境是否支持「智能分组」查询 —— 由 CLI 按 OA 版本判定（与 todoStat / planJson 的门禁同源）。
+        // 模型直接按它分流即可：true ⇒ 先 todoStat 统计再带 planJson 取数；false ⇒ 直接 workflow.search，
+        // CLI 自身输出分组统计与卡片。**不必自己比版本号**（比法容易出错），也**不需要"先空跑一次
+        // workflow.search 看模式"**。版本未知（会话取不到）⇒ 按不支持处理。
+        oaContext.smartGrouping = Boolean(version)
+            && isVersionAtLeast(oaVersionTuple(version), SMART_GROUPING_MIN_OA_VERSION);
+        // 注意：判据只看「有没有版本/身份」——smartGrouping 恒有值，不能让它把 oaContextMissing 变成永远 false。
+        const hasOaContext = Boolean(version) || Object.keys(user).length > 0;
         result.oaContext = hasOaContext ? oaContext : null;
         result.oaContextMissing = !hasOaContext;
         if (!hasOaContext) {
@@ -4234,3 +4888,31 @@ export const workflowReadOperations = [
     workflowPageOpen,
     workflowMemoryPrompt,
 ];
+/**
+ * 供**批量范围驱动**复用：该大分类的「全部」子分类 tabid（todo=0 / done=50 / mine=100 / all=300）。
+ *
+ * 为什么批量范围驱动需要它：legacy（低版本）模式下 `workflow.search` 对未显式指定子分类的 `todo`
+ * 默认查「待处理(7)」（见 `buildSearchQuery` 步骤 2.5，V11.2 语义）。而**批量过滤列表端点**
+ * （`…/list/data/getTodoListData/batch/batch<X>`）在 tabid=7 下只返待处理 ⇒ 当范围里全是
+ * 抄送/传阅/转发类流程时**恒 0 条**，模型会把"取不到"报成"范围内没有数据"（2026-09-20 真实事故）。
+ * 范围驱动的语义是「该 scope 下的全部流程，再由 `batchType` 过滤可批量操作性」，故未指定子分类时
+ * 显式取「全部」；scope 显式给了 `subCategory`/`tabName`/`tabid` 则原样尊重。
+ */
+export function defaultTabIdOf(category) {
+    return DEFAULT_TABID[category] ?? DEFAULT_TABID.todo;
+}
+/**
+ * 供**批量操作的范围驱动**复用：以与 `workflow.search` **完全相同的口径**取数（返回 `data`）。
+ *
+ * 为什么要复用同一个 operation，而不是在批量里另写一条取数路径：批量门禁的放行依据是
+ * 「最近一次查询结果」的快照（`search-index.json`，由 search 内部**无条件**刷新）——批量自己
+ * 另写一条取数路径就会造成"查一个口径、门禁另一个口径"的分叉（V12 早期真实事故：模型按文档
+ * 查出来的 requestId 全被门禁判成"不在最近一次查询结果里"，只能反复重查反复试）。
+ *
+ * 调用方（`write.ts` 的 `runScopeDrivenBatch`）只消费 `total` 与 `cards[].requestId`；超线时
+ * `cards` 会被体积守卫移出 stdout，调用方需回退到刚刷新的索引快照取 ID。
+ */
+export async function runWorkflowSearch(args, env) {
+    const envelope = await workflowSearch.handler(args, env);
+    return (envelope?.data ?? {});
+}