weaver-work-cli 0.1.8 → 0.1.20

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,6 +1163,54 @@ function isActionableRemark(value) {
         return false;
     return Number(text) < 100;
 }
+/**
+ * `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))] ?? '';
+}
 function normalizeListResponse(response, category, categoryName, baseUrl = '') {
     const record = responseData(response);
     const data = record?.data && typeof record.data === 'object' ? record.data : {};
@@ -1214,6 +1247,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) : '',
@@ -1302,6 +1338,7 @@ const SLIM_INDEX_ITEM_KEYS = [
     'workflowName',
     'canSubmitRejectTransfer',
     'isRemark',
+    'isRemarkName',
     'finished',
     'overdue',
 ];
@@ -1480,7 +1517,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 +1530,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,7 +1614,6 @@ const workflowSearch = {
         if (totalOnly) {
             return workflowSuccess('workflow.search', {
                 type: 'workflowSearch',
-                renderMode: searchMode,
                 category,
                 categoryName: CATEGORY_NAMES[category],
                 total,
@@ -1588,7 +1625,6 @@ const workflowSearch = {
         const index = await saveListIndex(env, normalized);
         return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
             type: 'workflowSearch',
-            renderMode: searchMode,
             category,
             categoryName: CATEGORY_NAMES[category],
             total,
@@ -1629,11 +1665,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) ?? '';
@@ -2037,7 +2075,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',
@@ -2883,9 +2920,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 +3020,7 @@ const workflowDetail = {
                 '表单内容区只展示核心业务字段，跳过空值、技术字段、可编辑、操作按钮、岗位、部门、最后反馈时间等非必要字段',
                 '表单字段值必须原样展示 value，不能摘要、改写、删减；字段含 valueHtml/links 时优先渲染为可点击超链接，不要把长 URL 直接作为普通文本换行展示',
                 'displayMode=longTextBlock 或 fullWidth=true 的表单字段必须全宽展示，保留原文、标点和换行；不要保留接口富文本里的背景色、字号和大段空白',
-                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按三行展示（操作人/方式/时间、接收人、签字意见内容）',
+                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按两行展示（操作人/方式/时间、签字意见内容）',
                 '签字意见区标题写成「签字意见（{{paginationText}}）」；只有 requestLog.hasMore=true 时才显示 nextPagePrompt',
                 '不要展示 requestId；不要展示 workflowName，用户明确询问所属工作流时才展示为「工作流名称」；不要翻译、音译或改写接口返回文本',
                 '详情面板后不要输出固定建议列表或「如果想进一步操作」类尾巴；用户要求摘要/总结时改为围绕表单业务内容提炼，不要渲染详情表',
@@ -3043,7 +3080,7 @@ function normalizeDetailResponse(response) {
         warnings.push('接口未返回该流程的任何详情内容（流程标题/编号/发起人/发起时间/当前节点/表单字段全为空）。'
             + '这不代表"流程是空的"，也不代表流程一定不存在——最可能是这个 requestId 在本环境查不到对应流程'
             + '（编号抄错、来自其他环境、已被删除）。'
-            + '请先用 `workflow.search` / `workflow.createList` 在本环境确认该流程可见、并直接从那一次的'
+            + '请先用 `workflow.search` 在本环境确认该流程可见、并直接从那一次的'
             + '`cards[].requestId` 取值，再重试；若确认流程存在却仍取不到，请如实告知用户"详情不可见"，'
             + '不要编造流程内容。');
     }
@@ -3204,19 +3241,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 +3285,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 +3326,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 +3357,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 +3385,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 +3405,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 +3429,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 +3451,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 +3459,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 +3552,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 +3571,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 +3585,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 +3657,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 +3664,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();
@@ -4192,8 +4080,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 +4101,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 +4129,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 ?? {});
+}

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

@@ -65,6 +65,27 @@ export function asStringArray(value, field) {
     }
     return value.map((item) => String(item));
 }
+/**
+ * 解析 `名称(ID)` / 纯 ID / 纯名称 → `{name, id}`。ID 必须是**纯数字**才认定为 ID。
+ *
+ * 查询侧（`read.ts` 的系统字段名称→ID）与发起侧（`form.ts` 的可发起工作流解析）共用同一
+ * 解析口径：澄清候选回传的就是 `名称(ID)`，两边若各写一份，一旦正则口径分叉就会出现
+ * 「查询侧认、发起侧不认」这类只有真机才暴露的错位。
+ */
+export 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 };
+}
 /** 请求 flag 是否开启（支持布尔与 0/1、"true"/"false"）。 */
 export function asBool(value, fallback = false) {
     if (value === undefined || value === null || value === '')