weaver-work-cli 0.1.7 → 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, 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',
 ];
@@ -1448,7 +1485,6 @@ const workflowSearch = {
         tabid: { type: 'string', description: '细分子类 tabid' },
         tabName: { type: 'string', description: '细分子类名称' },
         subCategory: { type: 'string', description: '细分子类名称或 tabid' },
-        keyword: { type: 'array', items: { type: 'string' }, description: '实体关键词（辅助解析）' },
         creator: { type: 'string', description: '发起人姓名，支持 "名称(ID)"；纯名称多命中返回澄清候选，0 命中报错（对齐 V11.3）' },
         creatorDept: { type: 'string', description: '发起人部门；纯名称多命中返回澄清候选，0 命中报错' },
         creatorSubcom: { type: 'string', description: '发起人分部；纯名称多命中返回澄清候选，0 命中报错' },
@@ -1481,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'],
@@ -1495,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 的
@@ -1577,7 +1614,6 @@ const workflowSearch = {
         if (totalOnly) {
             return workflowSuccess('workflow.search', {
                 type: 'workflowSearch',
-                renderMode: searchMode,
                 category,
                 categoryName: CATEGORY_NAMES[category],
                 total,
@@ -1589,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,
@@ -1630,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) ?? '';
@@ -2038,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',
@@ -2884,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({
@@ -2984,7 +3020,7 @@ const workflowDetail = {
                 '表单内容区只展示核心业务字段，跳过空值、技术字段、可编辑、操作按钮、岗位、部门、最后反馈时间等非必要字段',
                 '表单字段值必须原样展示 value，不能摘要、改写、删减；字段含 valueHtml/links 时优先渲染为可点击超链接，不要把长 URL 直接作为普通文本换行展示',
                 'displayMode=longTextBlock 或 fullWidth=true 的表单字段必须全宽展示，保留原文、标点和换行；不要保留接口富文本里的背景色、字号和大段空白',
-                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按三行展示（操作人/方式/时间、接收人、签字意见内容）',
+                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按两行展示（操作人/方式/时间、签字意见内容）',
                 '签字意见区标题写成「签字意见（{{paginationText}}）」；只有 requestLog.hasMore=true 时才显示 nextPagePrompt',
                 '不要展示 requestId；不要展示 workflowName，用户明确询问所属工作流时才展示为「工作流名称」；不要翻译、音译或改写接口返回文本',
                 '详情面板后不要输出固定建议列表或「如果想进一步操作」类尾巴；用户要求摘要/总结时改为围绕表单业务内容提炼，不要渲染详情表',
@@ -2993,8 +3029,12 @@ const workflowDetail = {
     },
 };
 function normalizeDetailResponse(response) {
-    const record = responseData(response);
-    const data = record?.data && typeof record.data === 'object' ? record.data : {};
+    // ★ 层级：`detailDataOf` 负责"`responseData()` 已解一层 `data`"这件事（真机实测响应为
+    // `{message, data:{workflowBaseInfo, otherInfo, formData}}`、**无内层 `data`**，与 V11.3 同口径）。
+    // 旧实现在这里又取了一次 `.data` ⇒ 实际拿到 `response.data.data`（不存在）⇒ `workflow.detail` 与
+    // `workflow.summary` **恒空**（basicInfo 全空、formData.available=false），`workflow.write` 的操作
+    // 门禁也因同源写法读不到 `mapItem` ⇒ 拦截失效。详见 `detailDataOf` 的注释与 PITFALLS A.50。
+    const data = detailDataOf(response);
     const base = data.workflowBaseInfo && typeof data.workflowBaseInfo === 'object' ? data.workflowBaseInfo : {};
     const other = data.otherInfo && typeof data.otherInfo === 'object' ? data.otherInfo : {};
     const currentNodes = toArray(base.currentNodeList ?? []);
@@ -3010,11 +3050,40 @@ function normalizeDetailResponse(response) {
         creatorName: pickText(base, 'creatorLastName', 'createrName', 'creatorName'),
         createdAt: pickText(base, 'createDateTime', 'createTime'),
         currentNode: currentNode || pickText(base, 'currentNodeName', 'nodeName'),
-        requestLevel: pickText(base, 'requestLevelShow', 'requestlevelShow', 'requestLevelTitle', 'requestlevelTitle') || asString(base.requestLevel),
-        flowStatus: pickText(base, 'flowstatusShow', 'status') || asString(base.flowStatus),
+        // 这两项的口径与列表侧（本文件 `:1396`/`:1432`）一致，也与 V11.3 `normalize_workflow_detail_response`
+        // （`:3716`/`:3721`）逐字对齐：接口的 `flowStatus` 是 `{code,desc,...}` 对象、`requestLevel` 是
+        // `0/1/2` 编码，**必须先过归一化函数**。旧写法直接 `asString(...)` ⇒ 详情面板里流程状态显示成
+        // "[object Object]"、紧急程度显示成裸数字。
+        // 这两项的口径与列表侧（本文件 `:1396`/`:1432`）一致，也与 V11.3 `normalize_workflow_detail_response`
+        // （`:3716`/`:3721`）逐字对齐：接口的 `flowStatus` 是 `{code,desc,...}` 对象、`requestLevel` 是
+        // `0/1/2` 编码，**必须先过归一化函数**。旧写法直接 `asString(...)` ⇒ 详情面板里流程状态显示成
+        // "[object Object]"、紧急程度显示成裸数字。
+        requestLevel: requestLevelText(pickText(base, 'requestLevelShow', 'requestlevelShow', 'requestLevelTitle', 'requestlevelTitle')
+            || base.requestLevel),
+        flowStatus: flowStatusText(base.flowStatus) || pickText(base, 'flowstatusShow', 'status'),
     };
     const formFields = extractFormFields(data);
     const formLogs = extractRequestLogs(data);
+    // ★ 静默失败防线：接口成功但什么都没返回时，不能产出 `warnings: []` + 全空 basicInfo ——
+    // 模型看到的是一个"成功但空白"的结果，既不知道是查不到、没权限还是参数错，容易当"流程是空的"。
+    // （2026-09-19 追查：当时线上"detail 恒空"的**真根因**是 `responseData()` 之后又多解了一层
+    //  `data`（见 `detailDataOf`），已修；本 warnings 保留，作为**真的取不到**时的兜底。）
+    const detailEmpty = !basicInfo.requestTitle
+        && !basicInfo.workflowName
+        && !basicInfo.requestMark
+        && !basicInfo.createdAt
+        && !basicInfo.creatorName
+        && !basicInfo.currentNode
+        && formFields.length === 0;
+    const warnings = [];
+    if (detailEmpty) {
+        warnings.push('接口未返回该流程的任何详情内容（流程标题/编号/发起人/发起时间/当前节点/表单字段全为空）。'
+            + '这不代表"流程是空的"，也不代表流程一定不存在——最可能是这个 requestId 在本环境查不到对应流程'
+            + '（编号抄错、来自其他环境、已被删除）。'
+            + '请先用 `workflow.search` 在本环境确认该流程可见、并直接从那一次的'
+            + '`cards[].requestId` 取值，再重试；若确认流程存在却仍取不到，请如实告知用户"详情不可见"，'
+            + '不要编造流程内容。');
+    }
     return {
         basicInfo,
         formData: {
@@ -3023,7 +3092,7 @@ function normalizeDetailResponse(response) {
             fields: formFields,
         },
         requestLog: { available: formLogs.length > 0, items: formLogs },
-        warnings: [],
+        warnings,
     };
 }
 // 去 HTML 标签 + 反转义（来源：Python strip_html，L681）。模块级共用。
@@ -3164,85 +3233,365 @@ function extractFormFields(data) {
     }
     return fields;
 }
+// ---------------------------------------------------------------------------
+// 签字意见取值工具族（★ 2026-09-19 按 V11.3 逐函数对齐）
+//
+// V11.3 的链路：`extract_request_log_items(response)` → 取 `response["data"]` → 交给
+// `collect_detail_logs_from_obj` **递归收集**（list 逐项递归；dict 归一化后继续下钻 15 个候选键）。
+// V12 早期版本把"递归"退化成"枚举 4 条固定路径"（`data.list` / `data.records` …），而
+// `getRequestLog` 的真实响应是 `{message:{errcode,errmsg}, data:[…]}` —— **`data` 直接是数组**
+// ⇒ 四条路径全 miss ⇒ 签字意见恒为空。真机探针实测同一份响应：V11.3 解出 8 条、V12 解出 0 条。
+// 归一化侧的 `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',
+];
+/** 日志容器候选键（来源：V11.3 `collect_detail_logs_from_obj`）。 */
+const LOG_CONTAINER_KEYS = [
+    'requestLogList', 'requestLogs', 'logs', 'logList', 'operatorList', 'signList', 'remarkList',
+    'opinionList', 'records', 'rows', 'dataList', 'datas', 'children', 'items', 'list',
+];
+/** 详情里"日志容器"的键名特征（来源：V11.3 `DETAIL_LOG_CONTAINER_PATTERN`）。 */
+const LOG_CONTAINER_KEY_PATTERN = /log|日志|remark|opinion|sign|operate|审批|签字|流转/iu;
+const LOG_NODE_KEYS = [
+    'nodeName', 'node', 'activityName', 'activityname', 'activity', 'activityInfo', 'operateNode',
+    'operatenode', 'operateNodeName', 'operatenodename', 'nodeNameShow', 'nodeShow',
+];
+const LOG_OPERATOR_KEYS = [
+    'operatorName', 'operator', 'operatorUser', 'operatorUserName', 'operatorLastName',
+    'operatorLastname', 'operatorShow', 'operateUser', 'operateUserName', 'operateusername',
+    'operateUserShow', 'operateBy', 'operateByName', 'operaterName', 'operater', 'handlerUser',
+    'handlerUserName', 'userName', 'username', 'handlerName', 'handler', 'handleUser',
+    'handleUserName', 'receiverName', 'receiver', 'receiverUser', 'receiverUserName', 'resourceName',
+    'resource', 'createUser', 'createUserName', 'creator', 'creatorName', 'creatorLastName',
+    'lastName', 'lastname',
+];
+const LOG_TIME_KEYS = [
+    'operateTime', 'operatetime', 'operateDateTime', 'operatedatetime', 'operatorTime',
+    'handlerTime', 'handleTime', 'receiveTime', 'createTime', 'createdTime', 'createdatetime',
+    'createDateTime', 'dateTime', 'datetime', 'time',
+];
+const LOG_ACTION_KEYS = [
+    'commentName', 'commentname', 'operateType', 'operateTypeName', 'operateTypeShow', 'operateName',
+    'operateNameShow', 'operation', 'operationName', 'operationType', 'operationTypeName', 'action',
+    'actionName', 'actionType', 'dealType', 'dealTypeName', 'handleType', 'handleTypeName',
+    'submitType', 'submitTypeName', 'typeName', 'typeShow', 'status', 'statusName', 'statusShow',
+    'logType', 'requestLogType',
+];
+const LOG_OPINION_KEYS = [
+    'opinion', 'remark', 'remarks', 'signRemark', 'signremark', 'content', 'comment', 'message',
+    'requestLogContent', 'commentContent', 'commentcontent',
+];
+/** 宽松取键：先精确匹配、再忽略大小写（来源：V11.3 `pick_raw`）。 */
+function pickRawLoose(source, ...keys) {
+    if (!source || typeof source !== 'object' || Array.isArray(source))
+        return undefined;
+    const record = source;
+    for (const key of keys) {
+        if (key in record)
+            return record[key];
+    }
+    const lowered = new Map();
+    for (const [key, value] of Object.entries(record))
+        lowered.set(key.toLowerCase(), value);
+    for (const key of keys) {
+        const hit = lowered.get(key.toLowerCase());
+        if (hit !== undefined)
+            return hit;
+    }
+    return undefined;
+}
+/**
+ * 任意值 → 展示文本（来源：V11.3 `display_text_from_value`）。
+ *
+ * 这是"签名里放的是对象"也能读出来的关键：先按 `DISPLAY_TEXT_KEYS` 取（`commentor` 对象因此
+ * 取到 `name`），再下钻常见包裹键，最后才 `stripHtml`；深度上限 4，避免环。
+ */
+function displayTextFromValue(value, depth = 0) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string' && !value.trim())
+        return '';
+    if (Array.isArray(value) && value.length === 0)
+        return '';
+    if (depth > 4)
+        return '';
+    if (Array.isArray(value)) {
+        return value.map((item) => displayTextFromValue(item, depth + 1)).filter(Boolean).join('、');
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        if (Object.keys(record).length === 0)
+            return '';
+        // ★ 必须走 `pickRawLoose`（大小写不敏感）：实测服务端回的对象键常与候选键大小写不一致
+        // （如 `UserName` 对上候选键 `userName`）—— 用 `in` 精确匹配会取不到值。
+        for (const key of LOG_DISPLAY_TEXT_KEYS) {
+            const raw = pickRawLoose(record, key);
+            if (raw === undefined)
+                continue;
+            const text = displayTextFromValue(raw, depth + 1);
+            if (text)
+                return text;
+        }
+        for (const key of ['browserDatas', 'resource', 'resourceInfo', 'hrmResource', 'user', 'userInfo', 'userBaseInfo', 'baseInfo', 'person', 'identity', 'operator', 'handler', 'receiver', 'creator', 'data']) {
+            const raw = pickRawLoose(record, key);
+            if (raw === undefined)
+                continue;
+            const text = displayTextFromValue(raw, depth + 1);
+            if (text)
+                return text;
+        }
+        return '';
+    }
+    return stripHtml(value);
+}
+/** 按候选键取展示文本（来源：V11.3 `pick_display_text`）。 */
+function pickDisplayText(source, ...keys) {
+    for (const key of keys) {
+        const text = displayTextFromValue(pickRawLoose(source, key));
+        if (text)
+            return text;
+    }
+    return '';
+}
+/** 数字串 → 本地可读时间（`YYYY-MM-DD HH:mm:ss`）。 */
+function formatLogTimestamp(ms) {
+    const date = new Date(ms);
+    if (Number.isNaN(date.getTime()))
+        return String(ms);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+        + `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+ * 时间文本归一化（来源：V11.3 `normalize_log_time_text`）。
+ *
+ * 接口给的是**毫秒时间戳**（如 `1743082059000`）—— 不处理就会在签字意见里裸显一串数字。
+ */
+function normalizeLogTimeText(value) {
+    const clean = stripHtml(value);
+    if (/^\d{13}$/u.test(clean))
+        return formatLogTimestamp(Number(clean));
+    if (/^\d{10}$/u.test(clean))
+        return formatLogTimestamp(Number(clean) * 1000);
+    return clean;
+}
+/** 去掉 `_weaverMte_` 系统标记（来源：V11.3 `strip_weaver_mte_tokens`）。 */
+function stripWeaverMteTokens(text) {
+    if (!text)
+        return text;
+    return text.replace(/_weaverMte_\S+/gu, ' ').replace(/\s+/gu, ' ').trim();
+}
+/**
+ * 递归收集日志条目（来源：V11.3 `collect_detail_logs_from_obj`）。
+ *
+ * ★ 关键在"递归"：`data` 可能是数组、也可能是对象里某个键下面挂着数组。V12 早期只枚举四条固定路径，
+ * 遇到 `getRequestLog` 的"`data` 是数组"形态就整条归零。
+ */
+function collectDetailLogsFromObj(obj, logs, limit) {
+    if (logs.length >= limit)
+        return;
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            collectDetailLogsFromObj(item, logs, limit);
+            if (logs.length >= limit)
+                break;
+        }
+        return;
+    }
+    if (!obj || typeof obj !== 'object')
+        return;
+    const record = obj;
+    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, limit);
+    }
+}
+/**
+ * 从接口响应里取出签字意见条目（来源：V11.3 `extract_request_log_items`）。
+ *
+ * 取 `response.data` 作为源（为空则回退整个 response），递归收集后按
+ * `node/operator/time/action/opinion` 五元组去重。
+ */
+function extractRequestLogItems(response, limit = 500) {
+    const wrapper = response && typeof response === 'object' && !Array.isArray(response)
+        ? response
+        : {};
+    let source = wrapper.data;
+    const emptySource = source === null || source === undefined || source === ''
+        || (Array.isArray(source) && source.length === 0)
+        || (typeof source === 'object' && !Array.isArray(source) && Object.keys(source).length === 0);
+    if (emptySource)
+        source = response;
+    const logs = [];
+    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.opinion]
+            .map((part) => String(part ?? ''))
+            .join('\u0001');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(log);
+    }
+    return unique;
+}
+/**
+ * 详情响应里的签字意见（来源：V11.3 `extract_detail_logs`）。
+ * 只认"键名像日志容器"的键，再走同一套递归收集 —— 不再枚举固定键名。
+ */
 function extractRequestLogs(data) {
-    const logKeys = ['requestLogList', 'requestLogs', 'logs', 'logList', 'signList', 'records'];
-    const out = [];
-    for (const key of logKeys) {
-        const arr = toArray(data?.[key]);
-        if (arr.length)
-            out.push(...arr.map((l) => normalizeLogItem(l)).filter((l) => l && detailLogHasContent(l)));
+    if (!data || typeof data !== 'object')
+        return [];
+    const logs = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (!LOG_CONTAINER_KEY_PATTERN.test(key))
+            continue;
+        if (value === null || value === undefined || value === '')
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        collectDetailLogsFromObj(value, logs, 40);
     }
-    return out;
+    return logs;
 }
 function detailLogHasContent(log) {
-    return Boolean(log && (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）
 // ---------------------------------------------------------------------------
+/** 响应里的显式 hasMore 标志（来源：V11.3 `response_has_more_flag`）。 */
+function responseHasMoreFlag(response) {
+    const wrapper = response && typeof response === 'object' && !Array.isArray(response)
+        ? response
+        : {};
+    const data = wrapper.data && typeof wrapper.data === 'object' && !Array.isArray(wrapper.data)
+        ? wrapper.data
+        : {};
+    const candidates = [];
+    for (const key of ['hasMore', 'hasNext', 'more', 'next']) {
+        if (key in wrapper)
+            candidates.push(wrapper[key]);
+        if (key in data)
+            candidates.push(data[key]);
+    }
+    for (const value of candidates) {
+        if (typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string') {
+            const lowered = value.trim().toLowerCase();
+            if (['true', '1', 'yes'].includes(lowered))
+                return true;
+            if (['false', '0', 'no'].includes(lowered))
+                return false;
+        }
+    }
+    return null;
+}
 async function fetchRequestLogPage(env, requestId, current, pageSize) {
     const session = await env.host.getSession();
-    const payload = { requestId, current: Math.max(1, current), pageSize: Math.max(1, Math.min(50, pageSize)) };
-    if (session.userId)
-        payload.userId = session.userId;
-    const response = await env.host.workflowRequest({
-        method: 'POST',
-        path: WORKFLOW_ENDPOINTS.REQUEST_LOG,
-        operation: 'workflow.requestLog',
-        body: payload,
-    });
-    const data = responseData(response);
-    const items = toArray(data?.data?.list ?? data?.data?.records ?? data?.list ?? data?.records ?? data?.records ?? [])
-        .map((l) => normalizeLogItem(l))
-        .filter((l) => detailLogHasContent(l));
+    const normalizedCurrent = Math.max(1, current || 1);
+    const normalizedPageSize = Math.max(1, Math.min(50, pageSize || 10));
+    const loadPage = async (page) => {
+        const body = { requestId, current: page, pageSize: normalizedPageSize };
+        if (session.userId)
+            body.userId = session.userId;
+        return env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.REQUEST_LOG,
+            operation: 'workflow.requestLog',
+            body,
+        });
+    };
+    const response = await loadPage(normalizedCurrent);
+    // ★ 取数按 V11.3 口径：把整个响应交给 `extractRequestLogItems`（取 `response.data` —— 实测是
+    // **数组** —— 再递归收集）。V12 早期写死 `data.list`/`data.records` 四个路径，数组形态全部 miss。
+    const items = extractRequestLogItems(response, normalizedPageSize * 2).slice(0, normalizedPageSize);
     const total = extractTotal(response);
     const totalReliable = total !== null;
-    const hasMore = asBool(data?.hasMore ?? data?.data?.hasMore, false) ||
-        (totalReliable ? current * pageSize < total : items.length >= pageSize);
+    const hasMoreFlag = responseHasMoreFlag(response);
+    let hasMore;
+    if (hasMoreFlag !== null) {
+        hasMore = hasMoreFlag;
+    }
+    else if (totalReliable) {
+        hasMore = normalizedCurrent * normalizedPageSize < total;
+    }
+    else if (items.length < normalizedPageSize) {
+        hasMore = false;
+    }
+    else {
+        // 本页已满且接口没给 total ⇒ 探测下一页（来源：V11.3 `fetch_request_log_page` 的 next_page_probe）。
+        // 直接假定 hasMore=true 会在最后一页误报"可继续查看第 N 页"。
+        hasMore = extractRequestLogItems(await loadPage(normalizedCurrent + 1), 1).length > 0;
+    }
     return {
         available: items.length > 0,
-        current,
-        pageSize,
+        current: normalizedCurrent,
+        pageSize: normalizedPageSize,
         currentPageCount: items.length,
         total,
         totalReliable,
         hasMore,
-        nextCurrent: hasMore ? current + 1 : null,
-        nextPagePrompt: hasMore ? `可继续查看第 ${current + 1} 页签字意见` : '',
+        nextCurrent: hasMore ? normalizedCurrent + 1 : null,
+        nextPagePrompt: hasMore ? `可继续查看第 ${normalizedCurrent + 1} 页签字意见` : '',
         items,
-        paginationText: `第 ${current} 页，每页 ${pageSize} 条`,
+        paginationText: `第 ${normalizedCurrent} 页，每页 ${normalizedPageSize} 条`,
         paginationNote: '签字意见按页展示；只有 hasMore=true 时才提示查看下一页',
     };
 }
+/**
+ * 签字意见单条归一化（来源：V11.3 `normalize_detail_log_item`）。
+ *
+ * 两处「V11.3 有、V12 缺」的处理，缺一个就会显示成空白或乱码：
+ * ① **操作人取 `commentor`** —— 真机实测该字段是**对象**（`{id, name:'孙一一', username}`），
+ *    必须走 `displayTextFromValue`；旧写法用 `pickText` 只会把对象 `String()` 成 `[object Object]`。
+ * ② **时间走 `normalizeLogTimeText`** —— 接口给的是 **毫秒时间戳**（`1743082059000`）。
+ *
+ * 接收人（`receivedPersonIds` + `userDataMap` 解析）已按要求整体移除：解析链（`resolveReceivedPersons` /
+ * `userNameFromMap` / `collectUserDataMap` / `valueToIdList` 与 `LOG_RECEIVER_*_KEYS`）一并删除。
+ */
 function normalizeLogItem(item) {
     if (!item || typeof item !== 'object')
         return {};
-    const operator = pickText(item, 'operatorName', 'operator', 'operatorUser', 'userName', 'handlerName', 'creatorName', 'handleUser');
-    const action = pickText(item, 'commentName', 'operateType', 'operateTypeName', 'operationType', 'actionName', 'typeName', 'status', 'statusName');
-    const time = pickText(item, 'operateTime', 'operateDateTime', 'handlerTime', 'createTime', 'createdatetime', 'createDateTime', 'time');
-    let opinion = pickText(item, 'opinion', 'remark', 'signRemark', 'content', 'comment', 'message');
-    const receivers = pickText(item, 'receiverName', 'receivers', 'receivePersonName', 'receiver');
+    let node = pickDisplayText(item, ...LOG_NODE_KEYS);
+    if (/^\d{12,}$/u.test(stripHtml(node)))
+        node = '';
+    const commentorText = displayTextFromValue(pickRawLoose(item, 'commentor', 'commentorId', 'commentorid', 'commentorInfo'));
+    const operator = commentorText || pickDisplayText(item, ...LOG_OPERATOR_KEYS);
+    const time = normalizeLogTimeText(pickDisplayText(item, ...LOG_TIME_KEYS));
+    const action = pickDisplayText(item, ...LOG_ACTION_KEYS);
+    const opinion = stripWeaverMteTokens(pickDisplayText(item, ...LOG_OPINION_KEYS));
     const operatorDisplay = operator || '未返回';
     const actionDisplay = action || '未返回';
     const timeDisplay = time || '未返回';
     const opinionDisplay = opinion || '未填写意见';
     return {
+        node,
         operator,
         operatorDisplay,
         time,
         timeDisplay,
         action,
         actionDisplay,
+        operatorAction: `${operatorDisplay} · ${actionDisplay}`,
         operatorActionTime: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
-        receiverDisplay: receivers || '未返回',
         opinion,
         opinionDisplay,
         displayLines: {
             line1: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
-            line2: `接收人：${receivers || '未返回'}`,
             line3: opinionDisplay,
         },
-        displayLayout: 'threeLineSignatureOpinion',
+        displayLayout: 'twoLineSignatureOpinion',
     };
 }
 /** 详情字段取值：有 links 时优先渲染为可点击超链接（来源：Python detail_field_markdown_value） */
@@ -3308,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) ?? '未返回';
@@ -3316,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();
@@ -3734,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 = [
@@ -3755,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) {
@@ -3776,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 ?? {});
+}