weaver-work-cli 0.1.7 → 0.1.8

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

@@ -3939,13 +3939,69 @@ async function commandEditSave(args, env) {
 // ---------------------------------------------------------------------------
 // createList（查询可发起工作流）
 // ---------------------------------------------------------------------------
+/**
+ * `createList` 大输出保护。
+ *
+ * 未传 `name` / `workflowId` 时本命令返回**当前用户全部可发起工作流**，流程多的租户动辄数千个
+ * （线上实测某租户 3,862 个、美化后约 460 KB），远超宿主的单次输出线（≈28 KB）⇒ 会被截成
+ * 2048 B 预览，模型只能自己写脚本去读文件（线上会话即如此绕行）。
+ *
+ * 对齐同文件的 `compactFormOutput` 与 `read.ts` 的 `enforceSearchStdoutBudget`：超安全线时把
+ * 完整清单落盘，stdout 只保留前 `CREATE_LIST_INLINE_LIMIT` 条，并在**最前面**给出 `resultFile`
+ * （被截断也看得见）；落盘不可用时保持全量（宁大不丢数据），只补一句说明。
+ *
+ * 注意：本命令的 `SELECTED`（1 条）/ `NOT_FOUND`（0 条）分支体积天然很小，无需过此函数。
+ */
+const CREATE_LIST_INLINE_LIMIT = 100;
+async function compactCreateListOutput(payload, env) {
+    const bytes = stdoutBytesOf(payload);
+    if (bytes <= STDOUT_SAFE_BYTES)
+        return payload;
+    const workflows = toArray(payload.workflows);
+    const resultFile = await writeStateFileBestEffort('last_create_list.json', JSON.stringify(payload, null, 2), env.ctx);
+    if (!resultFile) {
+        return {
+            ...payload,
+            outputBytes: bytes,
+            largeOutputNotice: `可发起工作流较多（${workflows.length} 个）且本地落盘不可用，已按原样返回全量 workflows。`
+                + '请改用 name 或 workflowId 精确定位，不要整份读入上下文。',
+        };
+    }
+    return withLeadingMeta({
+        resultFile,
+        persistedResult: true,
+        outputBytes: bytes,
+        workflowsTotal: workflows.length,
+        workflowsTruncated: true,
+        largeOutputNotice: `可发起工作流较多（${workflows.length} 个），完整清单已写入 resultFile；`
+            + `stdout 只保留前 ${CREATE_LIST_INLINE_LIMIT} 条。`
+            + '需要更多候选时从 resultFile 按需提取（不要整份读入上下文）——更推荐直接传 `name`（按名称匹配）'
+            + '或 `workflowId`（精确校验）来定位，避免拉全量。读取本输出请一次读完，不要用 head/tail 截断。',
+    }, {
+        ...payload,
+        workflows: workflows.slice(0, CREATE_LIST_INLINE_LIMIT),
+    });
+}
 async function commandCreateList(args, env) {
+    const workflowId = String(args.workflowId ?? '').trim();
+    const name = String(args.name ?? '').trim();
+    // `name` 与 `workflowId` 都不传时**直接返回提示、不发请求**：这种调用（线上会话出现过
+    // `--input-json '{}'`）只会拿到当前用户的全部可发起工作流（线上实测 3,862 条），既定位不到
+    // 用户要的流程，体积也必然超输出线 —— 与其拉下来再落盘/截断兜底，不如根本不发这一次请求。
+    if (!workflowId && !name) {
+        return workflowSuccess('workflow.createList', {
+            status: 'MISSING_QUERY',
+            message: '未提供 name 或 workflowId，已跳过查询。不传这两个参数时只能拉取当前用户的全部可发起工作流，'
+                + '既无法定位到用户要的流程、体积也远超单次输出上限。'
+                + '请先用业务流程名称（name）做模糊匹配，或直接传已知的 workflowId 做精确校验。',
+            workflows: [],
+        });
+    }
     const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, { wfpBelongTypeCode: '1', loadOfsFlow: '0', clientCtrl: 1 });
     // requestJson 内部已解包一层（responseData），此处不可再取 .data
     const data = (response && typeof response === 'object') ? response : null;
     if (!data || typeof data !== 'object')
         throw workflowApiError('format_error', '工作流列表返回 data 格式错误');
-    const workflowId = String(args.workflowId ?? '').trim();
     if (workflowId) {
         const authorized = simplifyWorkflows(data);
         const exact = authorized.filter((item) => String(item.id ?? '').trim() === workflowId);
@@ -3959,15 +4015,15 @@ async function commandCreateList(args, env) {
         }
         return workflowSuccess('workflow.createList', {
             status: 'NOT_FOUND',
-            query: args.name || '',
+            query: name,
             workflowId,
             message: '记忆中的 workflowId 不在当前用户可发起工作流列表中，可能已无发起权限或工作流已停用。',
             workflows: [],
         });
     }
-    const result = simplifyWorkflows(data, String(args.name ?? ''));
+    const result = simplifyWorkflows(data, name);
     if (!result.length) {
-        return workflowSuccess('workflow.createList', { status: 'NOT_FOUND', query: args.name || '', workflows: [] });
+        return workflowSuccess('workflow.createList', { status: 'NOT_FOUND', query: name, workflows: [] });
     }
     if (result.length === 1) {
         return workflowSuccess('workflow.createList', { status: 'SELECTED', workflow: result[0] });
@@ -3976,7 +4032,7 @@ async function commandCreateList(args, env) {
     // 对上「总部费用报销 / 总部费用报销流程 / 总部费用报销（自定义）」），就直接选中它，不让用户
     // 为"是不是要多打几个字"再选一次。这与查询侧 `resolveTerm` 的候选优选是**同一套判据**。
     // 只有在"没有任何候选与所写完全一致"（或完全一致的有多个、仍是歧义）时才请用户选择。
-    const keyword = String(args.name ?? '').trim().toLowerCase();
+    const keyword = name.toLowerCase();
     const exact = keyword
         ? result.filter((item) => String(item.workflowname ?? '').trim().toLowerCase() === keyword)
         : [];
@@ -3985,16 +4041,16 @@ async function commandCreateList(args, env) {
             status: 'SELECTED',
             workflow: exact[0],
             selectionSource: 'exactName',
-            message: `名称与「${args.name}」完全一致的工作流只有 1 个，已直接选中，无需用户选择。`,
+            message: `名称与「${name}」完全一致的工作流只有 1 个，已直接选中，无需用户选择。`,
         });
     }
     const selected = exact.length ? exact : result;
-    return workflowSuccess('workflow.createList', {
+    return workflowSuccess('workflow.createList', await compactCreateListOutput({
         status: 'NEEDS_SELECTION',
         message: '匹配到多个工作流，且其中没有与所写名称完全一致的，请让用户选择后再继续。',
-        query: args.name || '',
+        query: name,
         workflows: selected,
-    });
+    }, env));
 }
 function simplifyWorkflows(data, name = '') {
     const groups = Array.isArray(data.listDataGroup) ? data.listDataGroup : [];
@@ -4040,8 +4096,8 @@ const workflowCreateList = {
     risk: 'read',
     requiresConfirmation: false,
     inputSchema: schemaOf({
-        name: { type: 'string', description: '工作流名称关键字（模糊匹配）' },
-        workflowId: { type: 'string', description: '记忆中已确认的工作流 ID；传入时按当前用户可发起列表精确校验并优先选中' },
+        name: { type: 'string', description: '工作流名称关键字（模糊匹配）。**与 workflowId 至少传一个**——两个都不传时本命令不做查询，直接返回 status=MISSING_QUERY 的提示（不传参数只能拉取全部可发起工作流，无法定位用户要的流程）' },
+        workflowId: { type: 'string', description: '记忆中已确认的工作流 ID；传入时按当前用户可发起列表精确校验并优先选中。**与 name 至少传一个**' },
     }, { required: [] }),
     handler: (args, env) => commandCreateList(args, env),
 };

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, } 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';
@@ -1448,7 +1448,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 命中报错' },
@@ -2993,8 +2992,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 +3013,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` / `workflow.createList` 在本环境确认该流程可见、并直接从那一次的'
+            + '`cards[].requestId` 取值，再重试；若确认流程存在却仍取不到，请如实告知用户"详情不可见"，'
+            + '不要编造流程内容。');
+    }
     return {
         basicInfo,
         formData: {
@@ -3023,7 +3055,7 @@ function normalizeDetailResponse(response) {
             fields: formFields,
         },
         requestLog: { available: formLogs.length > 0, items: formLogs },
-        warnings: [],
+        warnings,
     };
 }
 // 去 HTML 标签 + 反转义（来源：Python strip_html，L681）。模块级共用。
@@ -3164,82 +3196,508 @@ 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 同样缺失 ⇒ 一并补齐。
+// ---------------------------------------------------------------------------
+/** 展示文本候选键（来源：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',
+    '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',
+];
+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))
+        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`（大小写不敏感）：实测 `userDataMap` 的键是 `UserName`（大写 U+N），
+        // 而候选键写的是 `userName`/`username` —— 用 `in` 精确匹配会取不到，接收人就只能显示裸 ID。
+        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 '';
+}
+/** 值 → 去重 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);
+    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();
+}
+/** 接收人（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) {
+    if (logs.length >= limit)
+        return;
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            collectDetailLogsFromObj(item, logs, userDataMap, limit);
+            if (logs.length >= limit)
+                break;
+        }
+        return;
+    }
+    if (!obj || typeof obj !== 'object')
+        return;
+    const record = obj;
+    const normalized = normalizeLogItem(record, userDataMap);
+    if (detailLogHasContent(normalized))
+        logs.push(normalized);
+    for (const key of LOG_CONTAINER_KEYS) {
+        if (key in record)
+            collectDetailLogsFromObj(record[key], logs, userDataMap, limit);
+    }
+}
+/**
+ * 从接口响应里取出签字意见条目（来源：V11.3 `extract_request_log_items`）。
+ *
+ * 取 `response.data` 作为源（为空则回退整个 response），递归收集后按
+ * `node/operator/time/action/receivers/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 userDataMap = collectUserDataMap(response);
+    const logs = [];
+    collectDetailLogsFromObj(source, logs, userDataMap, 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]
+            .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 userDataMap = collectUserDataMap(data);
+    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, userDataMap, 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 || log.receivers));
 }
 // ---------------------------------------------------------------------------
 // 签字意见归一化（来源：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 时才提示查看下一页',
     };
 }
-function normalizeLogItem(item) {
+/**
+ * 签字意见单条归一化（来源：V11.3 `normalize_detail_log_item`）。
+ *
+ * 三处「V11.3 有、V12 缺」的处理，缺一个就会显示成空白或乱码：
+ * ① **操作人取 `commentor`** —— 真机实测该字段是**对象**（`{id, name:'孙一一', username}`），
+ *    必须走 `displayTextFromValue`；旧写法用 `pickText` 只会把对象 `String()` 成 `[object Object]`。
+ * ② **时间走 `normalizeLogTimeText`** —— 接口给的是 **毫秒时间戳**（`1743082059000`）。
+ * ③ **接收人走 `resolveReceivedPersons`** —— `receivedPersonIds`（id 串）+ `userDataMap`（id→姓名）解析；
+ *    实测某条签字意见的接收人有 90+ 人，不解析就只能显示一串裸 ID。
+ */
+function normalizeLogItem(item, userDataMap = {}) {
     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');
+    const mergedMap = { ...userDataMap, ...collectUserDataMap(item) };
+    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 receivers = resolveReceivedPersons(item, mergedMap);
     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 || '未返回',
+        receiverIds: receivers.ids,
+        receivers: receivers.display,
+        receiverDisplay: receivers.display || '未返回',
         opinion,
         opinionDisplay,
         displayLines: {
             line1: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
-            line2: `接收人：${receivers || '未返回'}`,
+            line2: `接收人：${receivers.display || '未返回'}`,
             line3: opinionDisplay,
         },
         displayLayout: 'threeLineSignatureOpinion',

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

@@ -90,6 +90,29 @@ export function responseData(response) {
         return record.data;
     return response;
 }
+/**
+ * 流程详情接口（`getWorkflowRequest`）响应里的**业务对象**。
+ *
+ * ★ 层级口径（2026-09-19 真机 fetch 探针实测，别再猜）：真实响应是
+ * `{message, data:{workflowBaseInfo, otherInfo, formData}}` —— **只有一层 `data`**，
+ * 所以 `responseData()` 解掉外层之后**拿到的就是业务对象本身**。V11.3 同口径
+ * （`normalize_workflow_detail_response` 里 `response["data"]["workflowBaseInfo"]`，也只解一层）。
+ *
+ * 早期实现在 `responseData()` 之后**又取了一次 `.data`**（实际取到 `response.data.data`，不存在）
+ * ⇒ `workflow.detail` / `workflow.summary` 恒空（basicInfo 全空、`formData.available=false`），
+ * `workflow.write` 的授权门禁也因同源写法读不到 `mapItem`。
+ *
+ * 收口成本函数后两处共用，避免"一处改对、另一处忘了"（A.50）。
+ * 同时保留"某环境多包一层 `data`"的兜底，两种服务端实现都不会挂。
+ */
+export function detailDataOf(response) {
+    const root = responseData(response);
+    if (!root || typeof root !== 'object')
+        return {};
+    if ('workflowBaseInfo' in root || 'otherInfo' in root || 'formData' in root)
+        return root;
+    return root.data && typeof root.data === 'object' ? root.data : {};
+}
 /**
  * 记忆应用 ID（来源：原 Python `DEFAULT_MEMORY_APP_ID` / `memory_app_id_from_runtime`）。
  *

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

@@ -3,7 +3,7 @@ import { WorkflowCliError, workflowConfirmationError, workflowPartialError, work
 import { continuationReplayError } from '../continuation.js';
 import { rethrowAuthOrNetworkError } from './read.js';
 import { CONTINUATION_INPUT, SCHEMA_CATEGORY, SCHEMA_CONFIRM, SCHEMA_INDEX, SCHEMA_REQUEST_ID, schemaOf, workflowSuccess, } from './types.js';
-import { asInt, asString, asStringArray, compact, responseData, toArray, resolveMemoryAppId } from './shared.js';
+import { asInt, asString, asStringArray, compact, responseData, detailDataOf, toArray, resolveMemoryAppId } from './shared.js';
 import { WORKFLOW_ENDPOINTS } from '../endpoints.js';
 import { findIndexedItem, loadSearchIndex, } from '../state.js';
 // ===========================================================================
@@ -195,9 +195,15 @@ async function resolveTargetViaDetail(env, requestId, action) {
     catch {
         throw workflowValidationError('request_detail_unavailable', `无法获取流程 ${requestId} 详情以校验操作权限，已停止操作（请通过列表序号操作）`, { requestId });
     }
-    const data = responseData(detail)?.data;
-    const mapItem = (data && typeof data === 'object' && data.mapItem && typeof data.mapItem === 'object' ? data.mapItem : undefined)
-        ?? (data && typeof data === 'object' ? data : {});
+    // ★ 层级与 `normalizeDetailResponse` 同源：`detailDataOf` 已处理"`responseData()` 解过一层 `data`"
+    // （旧写法在这里又取一次 `.data` ⇒ 恒 undefined ⇒ 门禁永远拿不到 `mapItem`）。
+    // ⚠️ 但要清楚：该详情响应里**本来就没有** `mapItem` / `canSubmitRejectTransfer`（真机探针实测，
+    // 这两个字段只出现在列表 `displayData` 与会话映射里，`otherInfo` 常为空对象）⇒ 本函数在
+    // "直传 requestId"场景下通常仍拿不到门禁信息，`allowed` 为 undefined ⇒ **不拦截**。
+    // 这与 V11.3 的行为一致（`_normalized` 里没有 `mapItem` ⇒ 降级为 `{requestId}` ⇒ 同样不拦），
+    // 属于"缺少门禁数据"，不是"误放行"——修正层级只是让 fallback 逻辑按其本意生效。
+    const data = detailDataOf(detail);
+    const mapItem = (data.mapItem && typeof data.mapItem === 'object' ? data.mapItem : undefined) ?? data;
     const isRemark = String(mapItem.isremark ?? mapItem.isRemark ?? '');
     const allowed = mapItem.canSubmitRejectTransfer;
     const isSpecialSubmit = ['agree', 'submit'].includes(String(action ?? '')) &&

package/package.json

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

package/scripts/package-skill.mjs

@@ -77,6 +77,7 @@ function defaultOutput(skillNames) {
 function shouldSkip(entry, relativePath) {
   if (entry.name === '.DS_Store' || entry.name.startsWith('.')) return true
   if (relativePath === 'product.json') return true
+  if (relativePath === 'references/source-manifest.json') return true
   if (entry.isDirectory() && ['assets', 'node_modules', 'scripts'].includes(entry.name)) return true
   return false
 }

package/skills/weaver-e10-workflow/SKILL.md

@@ -48,7 +48,7 @@ User-Agent: AgentType=<agentType>,IsAgent=true
 1. **第一轮就并行发起（关键：不要串行拆成多轮往返）**：在**同一条消息**里同时发出下列调用——
    - Read `../weaver-e10-shared/SKILL.md`（若尚未读过）；
    - `weaver-work-cli --json workflow run workflow.memoryPrompt`——该命令**无入参**，命令形态已给定，**直接执行即可**（仅"非首次对话且距上次成功读取记忆不足 6 小时"时跳过）；
-   - **查询类意图**只读 [`workflow-query.md`](references/workflow-query.md) 一份（已覆盖 `workflow.search` 与 `workflow.todoStat`，不要再读其他查询文档）；**但该文件约 105 KB / 821 行、一次读不完**——按它开头的**「分段索引」分次读，单次 `limit` 不超过 150 行**：**首轮并行读契约段两次**（`offset 1 limit 122` 与 `offset 123 limit 122`，已覆盖 Operation、全部输入参数含「大分类判定」、时间条件与「待办时间默认语义」、执行流程），其余章节（`planJson` 编排、汇报式分组骨架、渲染规则与示例）**只在需要的那一刻按索引给出的行区间补读**；查看/操作/批量/共享/发起/修改等意图读对应那一份 reference 即可，不要顺手把查询文档也一起读；
+   - **查询类意图**只读 [`workflow-query.md`](references/workflow-query.md) 一份（已覆盖 `workflow.search` 与 `workflow.todoStat`，不要再读其他查询文档）；**但该文件约 105 KB / 820 行、一次读不完**——按它开头的**「分段索引」分次读，单次 `limit` 不超过 150 行**：**首轮并行读契约段两次**（`offset 1 limit 122` 与 `offset 123 limit 122`，已覆盖 Operation、全部输入参数含「大分类判定」、时间条件与「待办时间默认语义」、执行流程），其余章节（`planJson` 编排、汇报式分组骨架、渲染规则与示例）**只在需要的那一刻按索引给出的行区间补读**；查看/操作/批量/共享/发起/修改等意图读对应那一份 reference 即可，不要顺手把查询文档也一起读；
    - **泛化待办查询**（如"今天有哪些待办"）直接 `workflow.search`（category=todo，**不要带 `planJson`/`subCategory`**）——**不要在这一轮先调 `workflow.todoStat`**：模式由 CLI 判定并在返回的 `renderMode` 里给出，未确认前就调 todoStat 在低版本必然失败（报 `todo_stat_requires_smart_mode`）白费一次调用；返回 `renderMode=legacy` 时 CLI 已自带分组统计与卡片，原样渲染即结束，`renderMode=smart` 时才追加 `workflow.todoStat` 做统计规划。
    > 以上调用**互不依赖，必须并行**：串行拆轮会成倍拉长耗时。**实测基准**：一次泛化待办查询全程约 70s，其中**模型轮次占 ~95%**（每轮约 8~25s，主因是模型输出量），CLI 命令本身合计只有 1~2s。**能省一轮就省一轮**——尤其不要为"解析上一轮输出""取流程 ID"另起一轮。
    - **[`workflow-memory.md`](references/workflow-memory.md) 本步不读**——记忆读取的命令形态已在上一行给出（直接执行 `workflow.memoryPrompt` 即可），**记忆保存的规则已在本文件「记忆保存（全局规则）」章节给全**（本轮任务结束时按那一节执行）；只有需要判断"放 `user.md` / `memory.md` / `workflow:{id}` 哪一类"或其它字段细节时，才在需要的那一刻去读它。

package/skills/weaver-e10-workflow/references/source-manifest.json

@@ -9,7 +9,7 @@
     "kind": "workbuddy-script-skill",
     "availability": "local-installed-skill"
   },
-  "generatedAt": "2026-09-19T01:43:47Z",
+  "generatedAt": "2026-09-19T08:58:27Z",
   "sourceSet": {
     "aggregateSha256": "5bf1b914f284a8da850aab749bdee077070d8591f9a9fb658e5b10c5db923bbb",
     "sourceRoots": [
@@ -355,7 +355,6 @@
         "tabid",
         "tabName",
         "subCategory",
-        "keyword",
         "creator",
         "creatorDept",
         "creatorSubcom",
@@ -925,7 +924,7 @@
     }
   },
   "artifactBaseline": {
-    "aggregateSha256": "132371c2cb2a0fdd55d05bc20f74078f52ad845c759893167b454f2731e618dd",
+    "aggregateSha256": "9c49b24b03fc62f5355d942a911b7ed6b0c5983e9debbdaa87c22c8afe22247d",
     "files": [
       {
         "path": "skills/weaver-e10-workflow/references/workflow-agent-entry.md",
@@ -939,8 +938,8 @@
       },
       {
         "path": "skills/weaver-e10-workflow/references/workflow-create.md",
-        "size": 23807,
-        "sha256": "43dd2ac24dd52808e378a314936bce7febf61604c0e7a555505e39336794c66f"
+        "size": 24620,
+        "sha256": "58a88c9a6d13cc008d035727609bb5e6f6af48812d971eeaf8665695876b8efe"
       },
       {
         "path": "skills/weaver-e10-workflow/references/workflow-edit.md",
@@ -959,8 +958,8 @@
       },
       {
         "path": "skills/weaver-e10-workflow/references/workflow-query.md",
-        "size": 105456,
-        "sha256": "7717a8c5978874598cc89bf6cc3813d06a5b0402c0e4937218b0e9c887f02160"
+        "size": 105418,
+        "sha256": "675586b364b16a45864cfeb4318da5399e82cfa549127aa0c6a76d58a113b0b9"
       },
       {
         "path": "skills/weaver-e10-workflow/references/workflow-share.md",
@@ -969,13 +968,13 @@
       },
       {
         "path": "skills/weaver-e10-workflow/references/workflow-view.md",
-        "size": 10275,
-        "sha256": "e2b3a1651706919d0a64dfe7b3861f0accbc6a5aea893eebfa299b52832fea1d"
+        "size": 10834,
+        "sha256": "a819dec23a20dd2f9a4fb03a13a0aeb74e7f8815e968fd4e76917c126aadaa68"
       },
       {
         "path": "skills/weaver-e10-workflow/SKILL.md",
         "size": 35688,
-        "sha256": "ecfc4dd67a5389734698eca85d57ab688a0fb0e364db7e2ac5b35f539470aca8"
+        "sha256": "01ae14c997bfef2919db1f292314e3015de624217c062383f3c2e00fed436a32"
       },
       {
         "path": "src/shortcuts/workflow/continuation.ts",
@@ -1014,13 +1013,13 @@
       },
       {
         "path": "src/shortcuts/workflow/operations/form.ts",
-        "size": 191256,
-        "sha256": "2a7ee56ce0e8bc189d11ecd7bbe557769fe7c4489f182550abadb7210d0fc203"
+        "size": 194756,
+        "sha256": "40d0dda7b264bb9caa7022745e1fb467feee8a966a58797f94730caa74cbeb5b"
       },
       {
         "path": "src/shortcuts/workflow/operations/read.ts",
-        "size": 194246,
-        "sha256": "2a5045522214f14cb32b741bb93ebff1078f483729c2fc8f1d954400ad503581"
+        "size": 215109,
+        "sha256": "293c826b7d8f554f1945a9752e19e35f6fc59a91c267465b160aec92643ccafb"
       },
       {
         "path": "src/shortcuts/workflow/operations/registry.ts",
@@ -1029,8 +1028,8 @@
       },
       {
         "path": "src/shortcuts/workflow/operations/shared.ts",
-        "size": 6886,
-        "sha256": "5496922cb1807476f27b9da626b57b39fea020a4a267c70c2ae368e76a184544"
+        "size": 8206,
+        "sha256": "7517b587bd6c08d6a0ad6003a0fdd786e36e0eebb3beef922ab2650c5d9612a7"
       },
       {
         "path": "src/shortcuts/workflow/operations/types.ts",
@@ -1039,8 +1038,8 @@
       },
       {
         "path": "src/shortcuts/workflow/operations/write.ts",
-        "size": 102936,
-        "sha256": "bce32b59b3df196d5e65a8df59df719e0ba452294d2881a4c05a0a398df604f1"
+        "size": 103697,
+        "sha256": "78175dfa0168477efe3f3ebd8f1bad305d4f556e66c11724622bc2ce666ab2ee"
       },
       {
         "path": "src/shortcuts/workflow/state.ts",

package/skills/weaver-e10-workflow/references/workflow-create.md

@@ -8,7 +8,7 @@
 
 | Operation | 风险 | 固定规则 |
 | --- | --- | --- |
-| `workflow.createList` | read | 查询可发起工作流列表；不传凭据；`workflowId` 与 `name` 可同传精确校验 |
+| `workflow.createList` | read | 查询可发起工作流列表；不传凭据；`name`/`workflowId` **至少传一个**；`workflowId` 与 `name` 可同传精确校验 |
 | `workflow.createForm` | read | 必传 `workflowId`；`relatesTo` 仅透传不影响表单初始化；返回 `context`/runtime/frame/字段清单/fileUploadParams |
 | `workflow.createPrepare` | read-before-write | requiresConfirmation；必传 `context`/`data`/`intent`；`requestLevel` 取 `systemFields.levelOptions` 的 code，`secLevel` 取 `systemFields.secLevelOptions` 的 id；不落业务数据 |
 | `workflow.createApply` | high-risk-write | requiresConfirmation；必传 `confirm:true`/`context`/`intent`；`intent` 不继承 prepare；遇 `partial`/`write_uncertain` 禁止重试 |
@@ -33,7 +33,7 @@
 
 ### workflow.createList
 
-- `name`（string）：工作流名称关键字，模糊匹配。
+- `name`（string）：工作流名称关键字，模糊匹配。**与 `workflowId` 至少传一个**——两个都不传时 CLI **不做查询**（不发列表请求），直接返回 `MISSING_QUERY` 和提示。
 - `workflowId`（string，可选）：记忆中已确认的工作流 ID。记忆有 ID 时名称与 ID 同传，按当前用户可发起权限列表精确校验并优先选中；命中 `SELECTED`，未命中 `NOT_FOUND`，禁止去掉 ID 退回名称候选。
 
 **查询词策略（第 ① 步必读）**：
@@ -138,7 +138,7 @@ weaver-work-cli --json workflow run workflow.createApply --input-json '{"context
 
 ## 返回
 
-- createList：`SELECTED`/`NEEDS_SELECTION`/`NOT_FOUND`；候选工作流名原样展示，不加"推荐"后缀。
+- createList：`SELECTED`/`NEEDS_SELECTION`/`NOT_FOUND`/`MISSING_QUERY`；候选工作流名原样展示，不加"推荐"后缀。`MISSING_QUERY` ＝ `name` 与 `workflowId` 都没传，CLI **未发起查询**、`workflows` 为空 —— 补上名称或 ID 后重调即可（**不要试图拉全量再自己筛**）。**大清单形态**（`name` 命中太多、清单超 24 KB 时）：结果最前面多出 `resultFile` / `persistedResult` / `outputBytes` / `workflowsTotal` / `workflowsTruncated` / `largeOutputNotice`，且 `workflows` 只保留**前 100 条**——需要更多候选时从 `resultFile` 按需提取（**不要整份读入上下文**），更推荐把 `name` 写得更精确、或直接传 `workflowId` 来定位。
 - createForm：`context`、`runtime`、`frame`、`requiredFields`（字段 id 数组）、`subFormRequired`（subFormId → 字段 id 数组）、`editableFields`（**可写字段 id 白名单**）、`fields`（大表单时可能换成紧凑编码、或被整体移出 stdout —— 移出时同伴有 `writableFields`）、`initialValues`、`systemFields`、`fileUploadParams`、`requiredInfoWarning`、`conditionalRequired`（存在条件必填规则时才返回，见「注意」；**输出过大时它与 `editableFields` 一起移出 stdout、只留 `conditionalRequiredCount` 条数**，需要时按 `resultFile` 取）。
 - createPrepare：确认预览（`READY` 时在 `fields`）、`previewDetails`（明细表按列组织：`columns` 表头 + `rows` 每行明细，**仅 `READY` 时返回**；明细表按它排 Excel 列表格）、`resolvedValues`（`NEEDS_INPUT`/`NEEDS_CONFIRMATION` 时的解析回显）、`missing_fields`、`linkageResult`（联动带出/清空，原样转述）、`attachmentFolderIds`。
 - createApply：`finalMarkdown`、`requestId`、`requestMark`、标题、`url`；`finalMarkdown` 直接原样输出。`requestMark` 是用户可见流程编号（`finalMarkdown` 已按接口返回渲染：有值显示、无值不显示），`requestId` 只是系统内部流程请求 ID。**明细表展示**：`finalMarkdown` 中明细表已按 Excel 列展示（表头 + 每行明细），直接原样输出。

package/skills/weaver-e10-workflow/references/workflow-query.md

@@ -1,18 +1,18 @@
 # 流程查询（workflow.search / workflow.todoStat）
 
-> **分段索引 —— 本文件约 105 KB / 821 行，必须按段读：单次 `limit` 不超过 150 行，不要整读。**
+> **分段索引 —— 本文件约 105 KB / 820 行，必须按段读：单次 `limit` 不超过 150 行，不要整读。**
 > 单次读取过大会被宿主落盘、只回一小段预览，而那个落盘文件**不可读**（去读它只会拿到 `Permission … has been denied`，白费一轮）；读不全时回到本文件按行段重读即可。
 >
 > | 段落 | 行区间 | 读取方式 |
 > | --- | --- | --- |
-> | **契约段**：本索引 + Operation + 输入参数（分类 + 大分类判定 / 筛选 / 时间 / filterFields / 分页排序）+ 执行模式与返回形态 + 待办时间默认语义 + 命令参数反思 + 执行流程 | 1-244 | **首轮并行读两次**：`offset 1 limit 122`、`offset 123 limit 122` |
-> | `planJson` 批量编排 | 245-324 | 泛化待办 / 一次取多组数时读：`offset 245 limit 80` |
-> | 汇报式分组骨架 + 七个维度 + 参与身份与分组去向 + 常见业务重点字段 + 汇总渲染规则 + 渲染红线 | 325-507 | 需要输出分组结果前读（分两次）：`offset 325 limit 100`、`offset 425 limit 83` |
-> | 智能分组示例（各业务域样例，**仅供格式参照，不要照抄内容**） | 508-622 | 一般**不用读** |
-> | **异常返回处理 + 澄清后回传**（澄清信封、修正指令、认证失效） | 623-688 | 拿到 `ok:false` 或 `NEEDS_CLARIFICATION` 时读：`offset 623 limit 66` |
-> | 调用示例 | 689-767 | 需要时读：`offset 689 limit 79` |
-> | 返回（返回结构 / 错误码 / 幂等口径） | 768-807 | 处理 `ok` / `error` 时读：`offset 768 limit 40` |
-> | 注意 | 808-821 | 需要时读：`offset 808 limit 14` |
+> | **契约段**：本索引 + Operation + 输入参数（分类 + 大分类判定 / 筛选 / 时间 / filterFields / 分页排序）+ 执行模式与返回形态 + 待办时间默认语义 + 命令参数反思 + 执行流程 | 1-243 | **首轮并行读两次**：`offset 1 limit 122`、`offset 123 limit 122`（合计覆盖 1-244，含本段全部） |
+> | `planJson` 批量编排 | 244-323 | 泛化待办 / 一次取多组数时读：`offset 244 limit 80` |
+> | 汇报式分组骨架 + 七个维度 + 参与身份与分组去向 + 常见业务重点字段 + 汇总渲染规则 + 渲染红线 | 324-506 | 需要输出分组结果前读（分两次）：`offset 324 limit 100`、`offset 424 limit 83` |
+> | 智能分组示例（各业务域样例，**仅供格式参照，不要照抄内容**） | 507-621 | 一般**不用读** |
+> | **异常返回处理 + 澄清后回传**（澄清信封、修正指令、认证失效） | 622-687 | 拿到 `ok:false` 或 `NEEDS_CLARIFICATION` 时读：`offset 622 limit 66` |
+> | 调用示例 | 688-766 | 需要时读：`offset 688 limit 79` |
+> | 返回（返回结构 / 错误码 / 幂等口径） | 767-806 | 处理 `ok` / `error` 时读：`offset 767 limit 40` |
+> | 注意 | 807-820 | 需要时读：`offset 807 limit 14` |
 >
 > 行号以本索引为准；**改本文件时同步更新本索引**。按 `##` 标题定位同样有效。
 
@@ -96,7 +96,6 @@
 | 当前节点 ID | `nodeId`、`nodeIdTerm`（`in`/`notin`） | 节点 ID |
 | 流程状态 | `flowStatus`、`flowStatusTerm`（`in`/`notin`） | 状态值；`已结束` = 强制+正常结束 |
 | 精确过滤/排除 | `requestId`、`exRequestId` | 逗号分隔多个 requestId |
-| 实体关键词 | `keyword`（数组） | 辅助解析用的实体关键词 |
 | 排序 | `sort` | `"排序方式:asc\|desc"`，多组逗号分隔 |
 | 条件关系 | `conditionType` | `and`（默认）/`or` |
 

package/skills/weaver-e10-workflow/references/workflow-view.md

@@ -184,6 +184,7 @@ weaver-work-cli --json workflow run workflow.pageOpen --input-json '{"page":"vie
 - **摘要不标记已读**：`workflow.summary` 不改变流程未读状态；`workflow.detail` 会标记已读（用户主动查看语义），按需选择。
 - **定位纪律**：用户已给 `requestId` 时不要先查列表再过滤；分组场景必须 `group` + `index` 同时传；智能分组模式只传 `index`。
 - **大结果**：详情签字意见按 `requestLogPageSize` 分页，仅 `hasMore=true` 提示下一页；需要原始 JSON 时落本地文件返回路径。
+- **`warnings`（取不到详情时必须如实说）**：`workflow.detail` 在**接口返回成功但什么都没取到**（流程标题/编号/发起人/当前节点/表单字段全为空）时，会在 `warnings` 里给出原因提示。出现 `warnings` 时**必须原样转述给用户**——不要静默忽略，也不要把空详情当成"这个流程没有内容"就照常渲染空白面板；先核对 `requestId` 是否取自本环境查询结果的 `cards[].requestId`，确实取不到就如实说明详情不可见，不要编造流程内容。
 - **失败/停止**：CLI 失败时在 **stderr** 返回 `ok:false` + `error.type`/`error.subtype`/`error.message`/`error.retryable`（**没有** `success`/`stopReason`/`userMessage` 字段）——`retryable=true` 时最多重试一次，否则原样转述 `error.message` 并停止，不重试、不换接口。入参类错误（如 `locate_required`）按 `error.message` 补齐参数后重试一次。
 - **未登录/登录失效**：按 `weaver-e10-shared` 的 `references/e10-auth-and-session.md` 引导用户登录，登录后重放原请求（读操作可重放）。
 - **凭据禁止**：业务输入里禁止传入 Cookie、ETEAMSID、Token、`header.operator`，这些由 CLI 托管。

package/skills/weaver-e10-yepiaotong/references/invoice-issuing.md

@@ -28,7 +28,7 @@
 - 企业专票或需要企业抬头时：必须由用户或附件提供购方名称、税号；地址、电话、开户行和账号有明确来源时才填入，没有来源不要编造。
 - 从附件提取购方信息前，必须先提醒用户文件内容可能进入当前大模型上下文，并可能发送到解析服务，等待明确确认后再处理。
 
-CLI 会固定销方名称 `上海泛微网络科技股份有限公司`、销方税号 `9131000070322836XD`，并补齐 `billingType="0"`、`sourceType="4"`、`asyncCallFlag="1"`、`invoiceMethod="5"`、`taxSign="1"`。Agent 不要把 Cookie、ETEAMSID、业务 Token 或认证字段放入 payload。
+销方为 CLI 内置固定值（当前版本固定为销方名称 `上海泛微网络科技股份有限公司`、销方税号 `9131000070322836XD`，非按当前 E10 租户动态解析），Agent 无需也不应自行构造或改写销方字段；CLI 会一并补齐 `billingType="0"`、`sourceType="4"`、`asyncCallFlag="1"`、`invoiceMethod="5"`、`taxSign="1"`。Agent 不要把 Cookie、ETEAMSID、业务 Token 或认证字段放入 payload。
 
 ## 命令
 
@@ -37,13 +37,13 @@ CLI 会固定销方名称 `上海泛微网络科技股份有限公司`、销方
 Windows PowerShell：
 
 ```powershell
-weaver-work-cli --json invoice run invoice.issuing.make.prepare --input-json '{"mode":"ledger","payload":{"invoiceType":"8","externalDocumentNo":"AI-20260827-001","purchaserName":"XX科技有限公司","purchaserTaxNo":"91310000MA1234AB56","totalAmount":100,"taxAmount":6,"totalAmountWithTax":106,"details":[{"goodsName":"信息技术咨询服务","revenueCode":"3040205","taxRate":0.06,"amount":100,"amountWithTax":106,"taxAmount":6,"quantity":"1","unit":"项"}]}}'
+weaver-work-cli --json invoice run invoice.issuing.make.prepare --input-json '{"mode":"ledger","payload":{"invoiceType":"8","externalDocumentNo":"AI-EXAMPLE-001","purchaserName":"XX科技有限公司","purchaserTaxNo":"91310000MA1234AB56","totalAmount":100,"taxAmount":6,"totalAmountWithTax":106,"details":[{"goodsName":"信息技术咨询服务","revenueCode":"3040205","taxRate":0.06,"amount":100,"amountWithTax":106,"taxAmount":6,"quantity":"1","unit":"项"}]}}'
 ```
 
 macOS/Linux（bash/zsh）：
 
 ```bash
-weaver-work-cli --json invoice run invoice.issuing.make.prepare --input-json '{"mode":"ledger","payload":{"invoiceType":"8","externalDocumentNo":"AI-20260827-001","purchaserName":"XX科技有限公司","purchaserTaxNo":"91310000MA1234AB56","totalAmount":100,"taxAmount":6,"totalAmountWithTax":106,"details":[{"goodsName":"信息技术咨询服务","revenueCode":"3040205","taxRate":0.06,"amount":100,"amountWithTax":106,"taxAmount":6,"quantity":"1","unit":"项"}]}}'
+weaver-work-cli --json invoice run invoice.issuing.make.prepare --input-json '{"mode":"ledger","payload":{"invoiceType":"8","externalDocumentNo":"AI-EXAMPLE-001","purchaserName":"XX科技有限公司","purchaserTaxNo":"91310000MA1234AB56","totalAmount":100,"taxAmount":6,"totalAmountWithTax":106,"details":[{"goodsName":"信息技术咨询服务","revenueCode":"3040205","taxRate":0.06,"amount":100,"amountWithTax":106,"taxAmount":6,"quantity":"1","unit":"项"}]}}'
 ```
 
 复杂 payload 建议保存为 UTF-8 JSON 文件。
@@ -56,7 +56,7 @@ Set-Content -Encoding utf8 -LiteralPath .\issuing.json -Value @'
   "mode": "issue",
   "payload": {
     "invoiceType": "8",
-    "externalDocumentNo": "AI-20260827-001",
+    "externalDocumentNo": "AI-EXAMPLE-001",
     "purchaserName": "XX科技有限公司",
     "purchaserTaxNo": "91310000MA1234AB56",
     "totalAmount": 100,
@@ -77,7 +77,7 @@ cat > ./issuing.json <<'JSON'
   "mode": "issue",
   "payload": {
     "invoiceType": "8",
-    "externalDocumentNo": "AI-20260827-001",
+    "externalDocumentNo": "AI-EXAMPLE-001",
     "purchaserName": "XX科技有限公司",
     "purchaserTaxNo": "91310000MA1234AB56",
     "totalAmount": 100,

package/skills/weaver-e10-yepiaotong/references/reim-api-reference.md

@@ -194,7 +194,7 @@ CLI 信封中列表在 `data.items`。下面是单条发票的票面结构（对
           },
           "buyer": {
             "tcode": "9131000070322836XD",
-            "company": "泛微网络科技股份有限公司"
+            "company": "上海泛微网络科技股份有限公司"
           },
           "payer": {
             "tcode": "91460200348073438U",