weaver-work-cli 0.1.23 → 0.1.24

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

@@ -11,6 +11,7 @@ import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CATEGORY, SCHEMA_I
 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 { flowStatusCondition, FLOW_STATUS_HINT } from './flow-status.js';
 import { loadSearchIndex, saveSearchIndex, findIndexedItem, readStateFile, writeStateFileBestEffort, } from '../state.js';
 const ENDPOINT_PREFIX = {
     todo: 'TODO',
@@ -407,10 +408,10 @@ async function resolveTerm(env, systemKey, rawValue, label) {
         // 0 命中：只有 --workflow 澄清，其余系统字段一律失败（V11.3 口径）
         if (systemKey === 'workflowid') {
             throw workflowClarificationError(clarificationType, text, `${label}「${text}」未匹配到任何对象。请核对名称（是否写错字/少了字），`
-                + `或提供准确的完整名称（也可直接给工作流 ID）后再查。`);
+                + `或提供该对象的完整名称（或其它可用于检索的关键词）后再查。`);
         }
         throw workflowValidationError(`${systemKey}_not_found`, `${label}「${text}」未匹配到任何对象（该筛选条件不会生效，继续执行会返回不含该条件的全量数据），`
-            + '本次查询已停止。请核对名称，或改用「名称(ID)」/ 数字 ID 后重发。');
+            + '本次查询已停止。请核对名称，或提供该对象更完整的名称（或其它可用于检索的关键词）后重发。');
     }
     const exact = candidates.filter((item) => item.name.trim().toLowerCase() === text.trim().toLowerCase());
     if (exact.length === 1)
@@ -496,7 +497,7 @@ async function resolveRequestLevel(env, rawValue) {
         throw workflowClarificationError('system_relate_name2id_requestlevel', text, `紧急程度「${text}」匹配到 ${selected.length} 个等级，请确认要查询的具体等级。`, clarificationCandidates(selected, 10));
     }
     throw workflowValidationError('requestlevel_not_found', `紧急程度「${text}」未匹配到任何等级（该筛选条件不会生效），本次查询已停止。`
-        + `当前环境可选等级：${listed}。请核对后改用「名称(ID)」重发。`);
+        + `当前环境可选等级：${listed}。请从上面的等级名称中选一个后重发。`);
 }
 /** 时间条件 → formDatas 顶层键（来源：Python MEMORY_DATE_FORM_KEYS）。取值非法时按 V11.3 静默丢弃该条件。 */
 function applyTimeCondition(formDatas, fieldKey, raw) {
@@ -1012,16 +1013,39 @@ async function buildSearchQuery(env, args, mode) {
     if (requestLevel)
         formDatas.requestlevel = [{ content: requestLevel }];
     // 当前节点 ID
+    // ★ 浏览按钮类条件：只认 `[{term, browserDatas:[{id, name}]}]`。
+    //   旧实现写成 `[{content, term}]`（纯文本形态，那是 requestname/requestmark 的口径）
+    //   ⇒ 服务端**静默忽略**该条件、按节点筛选恒不生效——与 `flowstatus` 是同一类移植退化
+    //   （对照 `./flow-status.ts` 文件头）。节点是"浏览按钮"字段，不是文本字段。
+    //   来源：V11.3 `e10_workflow.py:10927-10931`，逐字为
+    //   `{"term": _node_term, "browserDatas": [{"id": nid, "name": ""} for nid in _node_ids]}`；
+    //   自动匹配路径 `:10637` 是 `[{"term": "in", "browserDatas": nodes}]`，nodes 形如 `{id, name}`。
+    //   **browserDatas 里真正起作用的只有 `id`**（用户 2026-09-28 澄清：真实抓包里的 content 等属性
+    //   都非必需）；本层拿不到节点名 ⇒ `name` 置空串，与 V11.3 的 `--node-id` 路径完全一致。
+    //   多值合并为「单个条件项 + 多 browserDatas」（同 workflowid 的口径），逐值拆成多个条件项会被
+    //   服务端按 AND 处理 → 恒 0 条。
     const nodeId = asString(args.nodeId);
     if (nodeId) {
         const term = asString(args.nodeIdTerm) === 'notin' ? 'notin' : 'in';
-        formDatas.nodeid = [{ content: nodeId, term }];
+        const nodeIds = nodeId.split(',').map((id) => id.trim()).filter(Boolean);
+        if (!nodeIds.length) {
+            throw workflowValidationError('node_id_empty', 'nodeId 必须是节点 ID（可逗号分隔多个），当前只传了分隔符。');
+        }
+        formDatas.nodeid = [{ term, browserDatas: nodeIds.map((id) => ({ id, name: '' })) }];
     }
     // 流程状态
+    // ★ 选项类条件：只认 `[{term, multiContent:[代码]}]`（见 `./flow-status.ts` 的文件头）。
+    //   旧实现写成 `[{content, term}]` ⇒ 服务端静默忽略该条件、按状态筛选恒不生效。
+    //   取值口径（方案 C）＝**只认四个代码、不做中文识别**；出现任何非代码取值即报错停止。
     const flowStatus = asString(args.flowStatus);
     if (flowStatus) {
-        const term = asString(args.flowStatusTerm) === 'notin' ? 'notin' : 'in';
-        formDatas.flowstatus = [{ content: flowStatus, term }];
+        const parsed = flowStatusCondition(flowStatus, args.flowStatusTerm);
+        if (!parsed || parsed.invalid.length) {
+            const offending = parsed?.invalid.length ? parsed.invalid.join('、') : flowStatus;
+            throw workflowValidationError('flow_status_unrecognized', `流程状态「${offending}」不是有效选项代码，本次已停止返回——静默丢弃该条件会退化成全量查询。`
+                + `可选值：${FLOW_STATUS_HINT}。`, { allowedFlowStatus: FLOW_STATUS_HINT });
+        }
+        formDatas.flowstatus = parsed.condition;
     }
     // 时间条件（来源：Python build_system_date_conditions——待办分类下移除操作时间条件：
     // 待办是"还未处理"的流程，操作时间（已操作过的时间）与待办状态语义矛盾）
@@ -1041,12 +1065,12 @@ async function buildSearchQuery(env, args, mode) {
     if (filterFieldsRaw.length) {
         if (!resolvedWorkflows.length) {
             throw workflowValidationError('field_require_workflow', '使用表单字段筛选时必须同时指定工作流（服务端只在该工作流的表单字段内匹配）。'
-                + '请先与用户确认要查哪个工作流，再用「名称(ID)」传入 workflow，并附上 filterFields。');
+                + '请先与用户确认要查哪个工作流——只问完整名称或其它可用于检索的关键词，不要向用户索取 ID——再由你按「名称(ID)」传入 workflow，并附上 filterFields。');
         }
         if (resolvedWorkflows.length > 1) {
             throw workflowValidationError('field_require_single_workflow', `表单字段筛选一次只能用于**单个**工作流，当前指定了 ${resolvedWorkflows.length} 个：`
                 + `${resolvedWorkflows.map((w) => `${w.name}(${w.id})`).join('；')}。`
-                + '请先把候选工作流展示给用户确认，再用「名称(ID)」传入单个 workflow 与 filterFields。', { candidates: resolvedWorkflows.map((w, index) => ({ index: index + 1, id: w.id, name: w.name })) });
+                + '请先把候选工作流展示给用户确认（只问完整名称或其它可用于检索的关键词，不要向用户索取 ID），再由你按「名称(ID)」传入单个 workflow 与 filterFields。', { candidates: resolvedWorkflows.map((w, index) => ({ index: index + 1, id: w.id, name: w.name })) });
         }
         const targetWorkflow = resolvedWorkflows[0];
         const workflowLabel = `${targetWorkflow.name || targetWorkflow.id}(${targetWorkflow.id})`;
@@ -1505,7 +1529,7 @@ const workflowSearch = {
         creatorDept: { type: 'string', description: '发起人部门；纯名称多命中返回澄清候选，0 命中报错' },
         creatorSubcom: { type: 'string', description: '发起人分部；纯名称多命中返回澄清候选，0 命中报错' },
         workflowType: { type: 'string', description: '工作流类型；纯名称多命中返回澄清候选，0 命中报错' },
-        workflow: { type: 'array', items: { type: 'string' }, description: '工作流条件，多个 or；支持 "名称(ID)"；纯名称未匹配到/匹配到多个且无全名精确匹配时返回澄清（候选见 candidates），确认后用「名称(ID)」重发' },
+        workflow: { type: 'array', items: { type: 'string' }, description: '工作流条件，多个 or；支持 "名称(ID)"；纯名称未匹配到/匹配到多个且无全名精确匹配时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称，不要向用户索取 ID）' },
         workflowTerm: { type: 'string', enum: ['in', 'notin'] },
         requestName: { type: 'string', description: '流程标题 like 模糊' },
         requestNameTerm: { type: 'string', enum: ['in', 'notin', 'eq', 'ne'] },
@@ -1514,9 +1538,9 @@ const workflowSearch = {
         requestLevel: { type: 'string', description: '紧急程度名称（CLI 按当前环境等级列表转 ID）；纯名称多命中返回澄清候选，0 命中报错并列出可选等级（对齐 V11.3）' },
         requestId: { type: 'string', description: '按 requestId 精确过滤，逗号分隔' },
         exRequestId: { type: 'string', description: '排除 requestId，逗号分隔' },
-        nodeId: { type: 'string', description: '当前节点 ID' },
+        nodeId: { type: 'string', description: '当前节点 ID，逗号分隔可多值（浏览按钮类条件，只能填节点 ID，不能填节点名称）' },
         nodeIdTerm: { type: 'string', enum: ['in', 'notin'] },
-        flowStatus: { type: 'string', description: '流程状态' },
+        flowStatus: { type: 'string', description: `流程状态（选项类，多选）：${FLOW_STATUS_HINT}` },
         flowStatusTerm: { type: 'string', enum: ['in', 'notin'] },
         createTime: { type: 'string', description: TIME_DESCRIPTIONS.createTime },
         operateTime: { type: 'string', description: TIME_DESCRIPTIONS.operateTime },
@@ -2406,7 +2430,7 @@ function planGroupError(groupName, error) {
         // 与 V11.3 的组内文案同口径（`_plan_system_field_form_datas`：
         // 「plan 内不做澄清，请改用 名称(ID) 形式」）——否则模型会把澄清问题当成"该组没有数据"。
         error: clarification
-            ? `${error.message}（plan 内不做澄清：请把候选原样交给用户确认，再用「名称(ID)」重跑该组）`
+            ? `${error.message}（plan 内不做澄清：请把候选原样交给用户确认——只问完整名称或其它可用于检索的关键词，不要向用户索取 ID；确认后由你按「名称(ID)」拼好重跑该组）`
             : error.message,
         ...(clarification
             ? {
@@ -2626,7 +2650,7 @@ async function executePlanSearch(env, plan, planPageSize = 10) {
             'plan 返回为批量编排结果：特殊组/展开组各段 finalMarkdown 均为纯卡片列表（无顶部行），原样粘贴到对应分组标题与一行汇总摘要下',
             '紧急/超时组标题计数：N=该组各槽 total 之和、M=urgent 槽 total、K=overtime 槽 total（0 项省略），如 ## 紧急/超时（2 条｜紧急 1 条｜超时 1 条）',
             '折叠组（collapsed=true）只返回 total 与 byWorkflow 数量，不展开明细；status=error 的组未取数，按 error 提示修正后可单独作为单条 workflow.search 查询',
-            'status=error 的组：原样把 error 交给用户。若该组同时带 clarificationType/candidates，说明是**名称没对上**（不是"该组没有数据"）——请把候选按「名称(ID)」摆给用户确认，再用该组条件单独发一次 workflow.search，禁止当作 0 条渲染或自行挑一个候选',
+            'status=error 的组：原样把 error 交给用户。若该组同时带 clarificationType/candidates，说明是**名称没对上**（不是"该组没有数据"）——请把候选摆给用户确认（只问完整名称或其它可用于检索的关键词，不要向用户索取 ID），确认后由你按「名称(ID)」拼好、用该组条件单独发一次 workflow.search，禁止当作 0 条渲染或自行挑一个候选',
             '任一流程只出现在一个分组：特殊组流程已注入 exRequestIds 从展开组排除',
             '展开组 pureDraft=true：该组卡片全部为本人待提交草稿（draftCount=total），不要渲染其 finalMarkdown（为空），全部并入折叠组「待提交草稿（N 条）」（N=各 pureDraft 组 draftCount 之和）',
             '展开组 pureDraft=false：其 finalMarkdown 已只渲染非草稿卡片（草稿卡片被剔除、数量见 draftCount），直接整段原样粘贴；组内草稿数量在标题/汇总注明即可，无需再逐条展示草稿',
@@ -4888,6 +4912,343 @@ export const workflowReadOperations = [
     workflowPageOpen,
     workflowMemoryPrompt,
 ];
+// ---------------------------------------------------------------------------
+// 「必填字段 → 历史可参考值」取数（`workflow.createForm` 内部调用，结果缓存进 continuation）
+//
+// 场景：发起流程时，先把**当前用户近一年内、非草稿（审批中＋已结束）**的最近 5 条「我发起的」
+// 流程，连同这些流程里**本次这张表单的字段取值**一起取回来，交给模型判断"能不能直接参考历史值
+// 补上必填项"——能补就不必去打扰用户。
+//
+// V12.1.77 起**调用点从 createRequest 前移到 createForm**（用户 2026-09-29 裁定）：
+//   · createForm 阶段就把结果算好，一部分（本表单的**必填字段**）随返回值给模型，让模型**第一次**
+//     `createRequest` 就能带上历史值；
+//   · 完整结果（本表单**全部**字段）缓存进 continuation 载荷，`createRequest` 遇到"新出现的必填
+//     字段"（createForm 当时还不是必填、多为联动后才变必填）时，直接从缓存里筛，**不再联网**。
+//   · 因此这里支持 `allFormFields`：保留**本表单**所有能取到值的字段，而不只是传入的 targets。
+//
+// 两次请求：
+//   ① 列表 `MINE_LIST`（**不调 total**：只要 5 条数据，总数没有意义）
+//   ② 明细 `REQUEST_DETAIL` ×N（**并行**）——`isGetRequestBaseInfo` / `isGetRequestLog` /
+//      `isReadRequest` 全 false、`isGetFormData` true。**`isReadRequest:false` 是关键**：
+//      一次内部取数不能把用户的历史单标成已读（`workflow.detail` 传的是 true，故不可复用）。
+//
+// 稳定性：这是**辅助信息**，失败不能拖垮发起链路 ⇒ 只有认证/网络错误原样上抛，其余错误一律
+// 降级为 `null`（对模型的文档口径：`null` = 没有可参考的历史数据，请直接向用户澄清）。
+// ---------------------------------------------------------------------------
+/** 历史参考数据条数上限。 */
+export const HISTORY_REQUEST_LIMIT = 5;
+/** 历史参考数据回溯窗口（天）：近一年。 */
+const HISTORY_LOOKBACK_DAYS = 365;
+/** 本地日期 → `YYYY-MM-DD`（不用 `toISOString`：那是 UTC，会跨日）。 */
+function formatLocalDate(date) {
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+/** 原始值是否"空"（空值不能作为参考值）。 */
+function isEmptyRawFieldValue(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length === 0;
+    return false;
+}
+/**
+ * 明细表单字段的**原始值**（保留对象形态，便于按字段类型格式化成可复用写法）。
+ *
+ * 与 `detailFormFieldValue` 同契约、同候选顺序，唯一区别是**不提前串化**——后者服务详情面板
+ * （只需要可读文本），前者服务历史参考值（还需要 `id` 才能拼出 `名称(id)`）。两处必须同步修改。
+ */
+function detailFormFieldRawValue(obj, formField) {
+    const dataKey = pickText(formField, 'dataKey', 'fieldKey', 'key');
+    const fieldId = pickText(formField, 'id', 'fieldId');
+    const fieldName = pickText(formField, 'title', 'fieldName', 'name', 'label');
+    const formData = obj?.formData;
+    if (formData && typeof formData === 'object') {
+        for (const key of [dataKey, fieldId, fieldName]) {
+            if (key && key in formData) {
+                const value = formData[key];
+                if (!isEmptyRawFieldValue(value))
+                    return value;
+            }
+        }
+    }
+    if (Array.isArray(obj?.dataOptions) && obj.dataOptions.length)
+        return obj.dataOptions;
+    for (const key of ['showValue', 'displayValue', 'fieldValue', 'value', 'content', 'text']) {
+        if (obj && typeof obj === 'object' && key in obj) {
+            const value = obj[key];
+            if (!isEmptyRawFieldValue(value))
+                return value;
+        }
+    }
+    return null;
+}
+/** 递归收集明细里的 `fieldId → 原始值`（只记**第一个非空**值，避免日志域的同 id 空值遮蔽真值）。 */
+function collectHistoryFieldRawValues(node, out, depth = 0) {
+    if (!node || typeof node !== 'object' || depth > 8)
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectHistoryFieldRawValues(item, out, depth + 1);
+        return;
+    }
+    const record = node;
+    const formField = record.formField;
+    if (formField && typeof formField === 'object') {
+        const fieldId = pickText(formField, 'id', 'fieldId');
+        if (fieldId && !out.has(fieldId)) {
+            const raw = detailFormFieldRawValue(record, formField);
+            if (raw !== null)
+                out.set(fieldId, raw);
+        }
+    }
+    for (const key of Object.keys(record)) {
+        const child = record[key];
+        if (child && typeof child === 'object')
+            collectHistoryFieldRawValues(child, out, depth + 1);
+    }
+}
+/** 从一个原始值里抽出 `名称 / ID` 对（浏览按钮、选项类字段的值都是这种形态）。 */
+function historyNameIdPairs(value) {
+    const pairs = [];
+    const visit = (item) => {
+        if (item === null || item === undefined)
+            return;
+        if (Array.isArray(item)) {
+            for (const child of item)
+                visit(child);
+            return;
+        }
+        if (typeof item === 'object') {
+            const name = pickText(item, 'name', 'showName', 'displayValue', 'showValue', 'label', 'title', 'lastName', 'userName', 'content', 'value');
+            const id = pickText(item, 'id', 'optionId', 'selectionId', 'valueKey', 'code', 'key', 'value');
+            if (name || id)
+                pairs.push({ name: name || id, id: id && id !== name ? id : '' });
+            return;
+        }
+        const text = String(item).trim();
+        if (text)
+            pairs.push({ name: text, id: '' });
+    };
+    visit(value);
+    return pairs;
+}
+/**
+ * 附件类字段（`FileComponent`）的**可直接复用**历史值。
+ *
+ * 为什么必须保留结构化对象：detail 接口对附件字段返回的本就是
+ * `{formField:{id}, dataOptions:[{optionId, content, type}]}`——`optionId` 是服务端的**附件 ID**、
+ * `type` 是文件类型（图片是 `image`、普通文件是 `file`）、`content` 是文件名。早先这里没有专门分支，
+ * 被 `stringifyDetailValue` 压成"只有文件名的字符串"，模型手里没有真 ID，只能拿文件名去拼一个
+ * ⇒ `saveFormData` 落库的附件对象指向不存在的文件（2026-09-30 真机会话实证：报错重试后命令
+ * 不报错、提交成功，但对象是错的）。信息本来就在，必须在格式化这一步留住。
+ *
+ * 任一项缺 `optionId`/`content` 时**不猜**：返回 `null` 让调用方退回纯文本形态（旧口径）。
+ */
+function historyAttachmentValue(raw, field) {
+    const fieldId = String(field?.id ?? '').trim();
+    if (!fieldId)
+        return null;
+    const options = [];
+    let incomplete = false;
+    const visit = (item) => {
+        if (item === null || item === undefined)
+            return;
+        if (Array.isArray(item)) {
+            for (const child of item)
+                visit(child);
+            return;
+        }
+        if (typeof item !== 'object')
+            return;
+        const optionId = pickText(item, 'optionId', 'fileId', 'fid');
+        const content = pickText(item, 'content', 'fileName', 'name', 'showName', 'label', 'title', 'value');
+        if (!optionId || !content) {
+            incomplete = true;
+            return;
+        }
+        const type = pickText(item, 'type', 'fileType');
+        options.push(type ? { optionId, content, type } : { optionId, content });
+    };
+    visit(raw);
+    if (incomplete || !options.length)
+        return null;
+    return { formField: { id: fieldId }, dataOptions: options };
+}
+/** 按字段类型把原始值格式化成"可直接复用"的写法。 */
+function formatHistoryFieldValue(raw, field) {
+    // 附件类：必须回到结构化对象，否则模型拿不到真 `optionId`/`type`（见 historyAttachmentValue）。
+    if (String(field?.componentKey ?? '').toLowerCase() === 'filecomponent') {
+        const attachment = historyAttachmentValue(raw, field);
+        if (attachment)
+            return attachment;
+    }
+    if (field?.isBrowser || field?.isSelect) {
+        const pairs = historyNameIdPairs(raw);
+        if (pairs.length) {
+            return pairs.map((pair) => (pair.id ? `${pair.name}(${pair.id})` : pair.name)).join('、');
+        }
+    }
+    return stringifyDetailValue(raw);
+}
+/**
+ * 取「历史流程可参考字段值」。返回 `null` 表示没有可参考的历史数据。
+ *
+ * - `fields`：当前表单布局里的字段清单（`context.fields`，用来判断字段是不是浏览按钮/选项类，
+ *   并在 `allFormFields` 档收口缓存范围——只有本表单的字段 id 会被保留）
+ * - `targets`：本次要取值的字段（`{id,name}` 或 `missingFields` 同形；`systemField` 项会被忽略）
+ * - `options.allFormFields`：见 `HistoryRequestDataOptions`
+ *
+ * 只保留**至少命中 1 个可参考字段值**的历史流程；系统字段（流程标题/紧急程度等）不参与。
+ */
+export async function buildHistoryRequestData(env, fields, targets, options = {}) {
+    const targetList = toArray(targets)
+        .filter((item) => !item?.systemField && String(item?.id ?? '').trim())
+        .map((item) => ({ id: String(item.id).trim(), name: String(item.name ?? item.id) }));
+    // 普通档必须真的有字段要取；缓存档允许 targets 为空（表单本身没有静态必填时，
+    // 缓存仍要建——条件必填是在 createRequest 阶段才现身的，那时已经没有联网取数的机会了）。
+    if (!targetList.length && !options.allFormFields)
+        return null;
+    const fieldMeta = new Map();
+    for (const field of toArray(fields))
+        fieldMeta.set(String(field?.id ?? ''), field);
+    // 取值顺序 = 「本表单布局顺序」（缓存档）或 targets 顺序（普通档）。
+    // 缓存档用布局顺序是为了结果稳定可 diff；但只保留本表单的字段 id，避免把别张表单的字段带进来。
+    const orderedIds = options.allFormFields
+        ? [...fieldMeta.keys()]
+        : targetList.map((t) => t.id);
+    const nameOf = new Map(targetList.map((t) => [t.id, t.name]));
+    try {
+        const now = new Date();
+        const start = new Date(now.getTime() - HISTORY_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
+        const historyWorkflowId = String(options.workflowId ?? '').trim();
+        const listResponse = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.MINE_LIST,
+            operation: 'workflow.createRequest.history',
+            body: {
+                params: { tabid: DEFAULT_TABID.mine, dimension: 'mine', flowSpareType: 1, outType: 0 },
+                searchParams: {
+                    formDatas: {
+                        // 非草稿 = 「未结束」+「已结束」（选项类系统条件必须是 multiContent，见 flow-status.ts；
+                        // 取值必须用**代码**——该模块只认四个选项代码，不吃中文）
+                        flowstatus: flowStatusCondition('notFinish,finish')?.condition ?? [],
+                        createdatetime: [{
+                                dateContent: [formatLocalDate(start), formatLocalDate(now)],
+                                term: 'like',
+                            }],
+                        // 只取**同一张表单**的历史（字段 id 是表单级的，跨表单必零交集，见 options.workflowId）。
+                        // 形态只认 `browserDatas`（workflowid 属"浏览按钮类"）：传 `multiContent` 会被服务端
+                        // **静默忽略**（HTTP 200、无报错、结果不变）——2026-09-29 实测踩过。
+                        ...(historyWorkflowId
+                            ? { workflowid: [{ term: 'in', browserDatas: [{ id: historyWorkflowId, name: '' }] }] }
+                            : {}),
+                    },
+                    type: 'and',
+                    initSearch: false,
+                },
+                customDisplayPage: { current: 1, size: HISTORY_REQUEST_LIMIT },
+                sortParams: [{ orderkey: SORT_OPTIONS['发起时间'], sortType: 'desc' }],
+            },
+        });
+        const listed = normalizeListResponse(listResponse, 'mine', CATEGORY_NAMES.mine);
+        const items = toArray(listed.items).slice(0, HISTORY_REQUEST_LIMIT);
+        const requestIds = items.map((item) => String(item?.requestId ?? '').trim()).filter(Boolean);
+        if (!requestIds.length)
+            return null;
+        const session = await env.host.getSession();
+        const details = await Promise.all(requestIds.map(async (requestId) => {
+            const payload = {
+                requestId,
+                isGetRequestBaseInfo: false,
+                isGetRequestLog: false,
+                isGetFormData: true,
+                isReadRequest: false,
+            };
+            if (session.userId)
+                payload.userId = session.userId;
+            const response = await env.host.workflowRequest({
+                method: 'POST',
+                path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+                operation: 'workflow.createRequest.history.detail',
+                body: payload,
+            });
+            return detailDataOf(response);
+        }));
+        const result = [];
+        for (let index = 0; index < details.length; index += 1) {
+            const data = details[index] || {};
+            const rawById = new Map();
+            collectHistoryFieldRawValues(data, rawById);
+            const fieldValues = [];
+            for (const fieldId of orderedIds) {
+                const raw = rawById.get(fieldId);
+                if (raw === undefined || raw === null)
+                    continue;
+                const value = formatHistoryFieldValue(raw, fieldMeta.get(fieldId));
+                // 附件类返回的是对象 ⇒ 不能再用 `String(value).trim()` 判空（那会得到 "[object Object]"）。
+                if (isEmptyRawFieldValue(value))
+                    continue;
+                fieldValues.push({
+                    fieldId,
+                    fieldName: nameOf.get(fieldId) || String(fieldMeta.get(fieldId)?.name ?? fieldId),
+                    value,
+                });
+            }
+            if (!fieldValues.length)
+                continue;
+            const base = data.workflowBaseInfo && typeof data.workflowBaseInfo === 'object' ? data.workflowBaseInfo : {};
+            const listedItem = items[index] || {};
+            result.push({
+                requestId: requestIds[index],
+                requestName: pickText(base, 'requestName', 'requestNameTitle')
+                    || String(listedItem.flowName ?? ''),
+                createTime: pickText(base, 'createDateTime', 'createTime')
+                    || String(listedItem.createdAt ?? ''),
+                fieldValues,
+            });
+        }
+        return result.length ? result : null;
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return null;
+    }
+}
+/**
+ * 从历史取数结果里筛出**指定字段**的取值（不改动传入对象）。
+ *
+ * 用途：`createForm` 缓存的是一份"本表单全部字段"的宽结果，`createRequest` 按当时真实的
+ * 缺失字段（或"新出现的必填字段"）在这里做二次筛选。
+ *
+ * 语义与取数同源：**某个字段一个值都没命中的历史流程整条剔除**；一条都不剩 ⇒ 返回 `null`
+ * （不塞空数组，避免模型误以为"有数据"）。
+ */
+export function filterHistoryRequestData(records, fieldIds) {
+    const wanted = new Set();
+    for (const id of fieldIds) {
+        const text = String(id ?? '').trim();
+        if (text)
+            wanted.add(text);
+    }
+    if (!wanted.size)
+        return null;
+    const result = [];
+    for (const record of toArray(records)) {
+        if (!record || typeof record !== 'object')
+            continue;
+        const fieldValues = toArray(record.fieldValues)
+            .filter((value) => value && wanted.has(String(value.fieldId ?? '')));
+        if (!fieldValues.length)
+            continue;
+        result.push({ ...record, fieldValues });
+    }
+    return result.length ? result : null;
+}
 /**
  * 供**批量范围驱动**复用：该大分类的「全部」子分类 tabid（todo=0 / done=50 / mine=100 / all=300）。
  *

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

@@ -181,6 +181,9 @@ export function withLeadingMeta(meta, body) {
  * 白花好几轮工具往返（实测某次会话多花 4 轮、约 54 s）。与其让宿主事后截，不如 CLI 主动落盘。
  *
  * **量这个线必须用 `stdoutBytesOf()`（美化口径）**，不能用压缩口径 —— 见该函数注释。
+ *
+ * 2026-09-29 备注：本线曾按用户要求临时抬到 `Number.MAX_SAFE_INTEGER`（去掉本地输出限制），
+ * 用于实测"命令输出到底会不会被宿主截断"；**实测已完成，本线已按原值恢复**（=24,000）。
  */
 export const STDOUT_SAFE_BYTES = 24_000;
 /** 结果序列化后的字节数（**压缩**口径，用作相对大小参考）。 */

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

@@ -126,12 +126,12 @@ async function resolveReceiverNames(env, receiverName) {
             ids.push(candidates[0].id);
         }
         else if (candidates.length > 1) {
-            throw workflowValidationError('receiver_ambiguous', `接收人「${part}」匹配到多个候选，请确认后回传 "名称(ID)"`, {
+            throw workflowValidationError('receiver_ambiguous', `接收人「${part}」匹配到多个候选，请把 candidates 原样交给用户确认是哪一个——只问完整姓名或其它可用于检索的关键词，不要向用户索取 ID；用户确认后由你按 "姓名(ID)" 拼好并重发同一条命令`, {
                 candidates: candidates.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })),
             });
         }
         else {
-            throw workflowValidationError('receiver_not_found', `未匹配到接收人「${part}」，请提供准确姓名或 "名称(ID)"`, {
+            throw workflowValidationError('receiver_not_found', `未匹配到接收人「${part}」，请提供该接收人的完整姓名（或其它可用于检索的关键词）`, {
                 receiverName: part,
             });
         }
@@ -557,7 +557,7 @@ async function resolveShareTarget(env, obj, minSec, maxSec) {
     const exact = candidates.filter((c) => c.name.trim().toLowerCase() === name.toLowerCase());
     const selected = exact.length === 1 ? exact : candidates;
     if (!selected.length) {
-        throw workflowValidationError('share_target_not_found', `共享对象「${name}（${scope}）」未匹配到任何候选，请核对名称或改用 "名称(ID)"`, { shareType: scope, name });
+        throw workflowValidationError('share_target_not_found', `共享对象「${name}（${scope}）」未匹配到任何候选，请核对名称，或提供该对象更完整的名称（或其它可用于检索的关键词）`, { shareType: scope, name });
     }
     if (selected.length !== 1) {
         // 多命中不是失败而是"需要澄清"：按 V11.3 语义以成功态返回候选（模型展示给用户后按
@@ -639,7 +639,7 @@ async function resolveForwardReceiver(env, obj) {
     const exact = candidates.filter((c) => c.name.trim().toLowerCase() === name.toLowerCase());
     const selected = exact.length === 1 ? exact : candidates;
     if (selected.length !== 1) {
-        throw workflowValidationError('forward_receiver_ambiguous', `转发接收人「${name}（${rtype}）」匹配到 ${selected.length} 个候选，请确认后回传 "名称(ID)"`, { candidates: selected.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })) });
+        throw workflowValidationError('forward_receiver_ambiguous', `转发接收人「${name}（${rtype}）」匹配到 ${selected.length} 个候选，请把 candidates 原样交给用户确认是哪一个——只问完整姓名或其它可用于检索的关键词，不要向用户索取 ID；用户确认后由你按 "姓名(ID)" 拼好并重发同一条命令`, { candidates: selected.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })) });
     }
     return { _entityType: rtype, id: selected[0].id };
 }
@@ -1216,7 +1216,7 @@ const workflowSharePrepare = {
                         clarificationQuestion: `共享对象「${err.payload.name}」匹配到多个候选，请确认要共享给哪一个。`,
                         candidates: err.payload.candidates,
                         displayRules: [
-                            'needClarification=true 时原样展示候选，等用户确认后用 "名称(ID)" 重新调用 workflow.sharePrepare',
+                            'needClarification=true 时原样展示候选，等用户确认后用 "名称(ID)" 重新调用 workflow.sharePrepare（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
                             '候选序号与显示名称保持原样，不要自行重建查询条件',
                         ],
                     });

package/dist/shortcuts/workflow/operations.js

@@ -85,20 +85,22 @@ function clarificationEnvelope(error, operation) {
 function clarificationNote(reason, candidateCount) {
     const base = '这不是失败，也**不代表查询已执行**：本次查询已停止，没有返回任何流程数据。';
     if (reason === 'workflow_not_exist') {
-        return base + '请如实告知用户：该工作流 ID 不存在（可能已删除或被停用），'
-            + '让用户核对 ID 或改用流程名称重新指定。**不要**说成"没有可发起的工作流"这类模糊说法——'
-            + '用户给的是一个具体 ID，问题就出在这个 ID 上。';
+        return base + '请如实告知用户：该工作流不存在（可能已删除或被停用），'
+            + '请用户改用该流程的完整名称（或其它可用于检索的关键词）重新指定——**不要向用户索取 ID**。'
+            + '**不要**说成"没有可发起的工作流"这类模糊说法——'
+            + '问题就出在这个目标上。';
     }
     if (reason === 'no_create_right') {
         return base + '请如实告知用户：该流程**存在**，但当前账号**没有发起权限**。'
             + '**必须明确说出「存在但没有发起权限」**，绝不能转述成"流程不存在"；'
             + '并给出下一步：改用其他可发起的流程，或联系管理员为该流程授予发起权限。';
     }
-    return base + '请把澄清问题与候选**原样**交给用户确认（逐条列出「名称(ID)」），'
-        + '拿到确认后用「名称(ID)」格式重发同一条命令。'
+    return base + '请把澄清问题与候选**原样**交给用户确认（逐条列出候选名称），'
+        + '拿到确认后由你按「名称(ID)」把 ID 拼好、重发同一条命令——'
+        + '**只问用户该对象的完整名称或其它可用于检索的关键词，不要向用户索取 ID**。'
         + '**不要**把本次结果转述成「没有匹配的流程」「查询结果为 0 条」或自行挑一个候选继续查。'
         + (candidateCount === 0
-            ? '当前没有任何候选——请让用户给出准确的完整名称（或纠正名称里的错别字）后重发。'
+            ? '当前没有任何候选——请让用户给出该对象的完整名称（或纠正名称里的错别字、换其它可用于检索的关键词）后重发。'
             : '');
 }
 /**

package/docs/caizhilian.md

@@ -293,12 +293,18 @@ weaver-work-cli --json caizhilian run caizhilian.attachment.download --input-jso
 | 加解密设置 | `caizhilian.setting-encrypt.*` | 8 项加解密配置 |
 | 存储设置 | `caizhilian.setting-storage.*` | 存储实例与规则管理 |
 | 文件采集 | `caizhilian.file-collection.*` | FTP/SFTP 文件采集任务管理 |
-| 文件上传 | `caizhilian.file-upload.*` | 本地文件上传到文件服务 |
+| 文件上传 | `caizhilian.file-upload.*` | 秒传、普通/分片流式上传、终态校验与私有回执 |
 
 详细用法参见各模块的 reference 文档。
 
+文件上传协议代码位于 `src/shortcuts/caizhilian/file-upload/`，按文件/上下文校验、流式 multipart、
+上传策略和回执分为四个模块；`operations/handlers/file-upload.ts` 接入现有 schema 与确认链。
+协议采用 `weaver-file-upload` 的上传契约，认证继续由 CLI 框架统一托管。
+新增的 `test/business/caizhilian-file-upload.test.ts` 使用本机 HTTP 服务验证实际传输格式和失败语义；
+本机验证不代表真实 E10 租户已验证。
+
 ## 验证状态
 
 - 已通过：`tsc --noEmit`、`npm run build`、`caizhilian schema` / `caizhilian operations` 实际输出、`test/business/caizhilian-operations.test.ts`（24 项）与 `test/business/caizhilian-command.test.ts`（5 项）。
 - **未过检测器**：本次生成没有可用的 Skill 检测器（`validate_skill.py`），因此交付状态标注为「未过检」。
-- **真实 E10 端到端目前只覆盖 `folder.query-by-permission`**：2026-09-21 在真实租户验证了按权限反查（默认共享 / 文档权限 × 人员 / 部门），并修复了 `object_ids` 转 number 导致的精度丢失缺陷；创建、共享、上传、下载与比对链路仍为离线契约级（fake host），未在真实 E10 环境跑通。
+- **真实 E10 端到端目前只覆盖 `folder.query-by-permission`**：2026-09-21 在真实租户验证了按权限反查（默认共享 / 文档权限 × 人员 / 部门），并修复了 `object_ids` 转 number 导致的精度丢失缺陷；创建、共享、上传、下载与比对链路仍为离线契约级（fake host），未在真实 E10 环境跑通。

package/docs/e10-auth.md

@@ -34,20 +34,35 @@ weaver-work-cli auth profile use PROFILE_NAME
 weaver-work-cli auth export-weaver-env
 ```
 
-`auth login` 和 `auth oidc` 都走 E10 OAuth2.0 浏览器授权登录，本地默认监听
+`auth login` 和 `auth oidc` 都严格走 E10 OAuth2.0 浏览器授权登录，不会读取或消费 XiaoE 统一登录凭据。本地默认监听
 `http://127.0.0.1:19800/callback`。如端口被占用，可以使用
 `--port 19801` 指定其他端口；如需要区分客户端来源，可以使用
 `--agent_type <value>`。未显式传入时，CLI 会依次读取 `WEAVER_AGENT_TYPE`、
 `WORKBUDDY_AGENT_TYPE`、`CODEX_AGENT_TYPE`，再根据 `WORKBUDDY_*` / `CODEX_*`
 环境变量推断当前宿主，最后回落为 `weaver-work-cli`。浏览器授权地址会同时携带
 `agent_type=<value>` 和 `from=<value>`，其中 `from` 用于 E10 授权确认页展示客户端名称。
-
-XiaoE 宿主环境中，`auth login` / `auth oidc` / `auth xiaoe` 先使用平台注入的 `XIAOE_USER_TOKEN` + `XIAOE_DOMAIN` 换取 ETEAMSID（沙箱/Linux 环境唯一可用来源）。这里的 `XIAOE_DOMAIN` 是 XiaoE/erpa 换票服务地址，不是 E10 登录地址。Node 主路径调用与 `xiaoe_env.py` / `tokens.py` 相同的接口，校验业务 `code`（`"0000"` 或 `200`）及 `data.eteamId`，保留系统 CA 校验，并只跟随同源重定向或同主机 HTTP→HTTPS 升级。Node 路径失败时，CLI 会在内部执行 npm 包自带的 `scripts/xiaoe_env.py` 兼容路径；它只依赖 Python 标准库，凭证 stdout 由 CLI 内部消费，不进入 Agent 上下文，也不会关闭 TLS 证书校验。之后才依次读取宿主 `xiaoeUserData/tokens.py`、桌面 XiaoE 客户端本地会话（macOS `~/Library/Application Support/XiaoE/Robots/<id>/user_settings.json`，Windows `%LOCALAPPDATA%/XiaoE/Robots/<id>/user_settings.json`）和 `WEAVER_XIAOE_*` ETEAMSID 映射。宿主不会注入 ETEAMSID 环境变量，CLI 也不读取 `XIAOE_ETEAMSID`。
+授权完成后的本地回调页会为已识别的桌面宿主显示应用打开弹层。CLI 内置 WorkBuddy
+（`workbuddy://`）、智能小 E（`xiaoe-client://`）和 Codex（`codex://`）映射；其他
+智能体在 `agent_type` 本身是合法协议名时，默认按 `<agent_type>://` 唤起。Windows/macOS
+安装包需要注册对应协议。弹层通过一次性令牌请求
+本地 CLI，再由 CLI 调用系统协议处理器，避免浏览器直接访问自定义协议时出现不可定制的
+Chrome/Edge 原生确认框。宿主需要返回特定会话时，可以传
+`--agent-return-url <自定义协议 URL>`，或注入 `WEAVER_AGENT_RETURN_URL`（命令行优先）。
+该显式地址也用于协议名与 `agent_type` 不一致的客户端。
+返回地址只接受桌面应用自定义协议，不接受 `http(s)`、脚本或本地文件 URL。“始终打开”
+偏好保存在当前本地回调地址的浏览器存储中。本地 CLI 打开通道默认保留 15 分钟；通道
+结束后页面会自动退回浏览器自定义协议打开方式，不直接显示网络请求错误。
+智能小 E 统一登录成功时不会经过浏览器；只有统一登录不可用并降级为桌面浏览器 OAuth 时，
+才显示“返回智能小 E”弹层。
+
+只有当前智能体身份明确为 XiaoE 时，`auth xiaoe` 和未显式指定认证来源的业务命令才先使用平台注入的 `XIAOE_USER_TOKEN` + `XIAOE_DOMAIN` 换取 ETEAMSID（沙箱/Linux 环境唯一可用来源）。这里的 `XIAOE_DOMAIN` 是 XiaoE/erpa 换票服务地址，不是 E10 登录地址。Node 主路径调用与 `xiaoe_env.py` / `tokens.py` 相同的接口，校验业务 `code`（`"0000"` 或 `200`）及 `data.eteamId`，保留系统 CA 校验，并只跟随同源重定向或同主机 HTTP→HTTPS 升级。Node 路径失败时，CLI 会在内部执行 npm 包自带的 `scripts/xiaoe_env.py` 兼容路径；它只依赖 Python 标准库，凭证 stdout 由 CLI 内部消费，不进入 Agent 上下文，也不会关闭 TLS 证书校验。之后才依次读取宿主 `xiaoeUserData/tokens.py`、桌面 XiaoE 客户端本地会话（macOS `~/Library/Application Support/XiaoE/Robots/<id>/user_settings.json`，Windows `%LOCALAPPDATA%/XiaoE/Robots/<id>/user_settings.json`）和 `WEAVER_XIAOE_*` ETEAMSID 映射。宿主不会注入 ETEAMSID 环境变量，CLI 也不读取 `XIAOE_ETEAMSID`。仅本机存在这些文件或配置不足以触发 XiaoE 登录。
 
 E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置/映射 → 当前 profile → `https://www.e-cology.com.cn`”解析，绝不会把 `XIAOE_DOMAIN` 当作 E10 地址。凭证可用时，CLI 直接保存登录态，保存的 `agentType` 固定为 `XiaoE`；业务命令在未显式指定 `--auth` / `--profile` 时，也会自动优先尝试 XiaoE 统一登录。统一登录失败后，`auth xiaoe` 仅在 macOS/Windows 桌面宿主自动降级浏览器 OAuth；Web/Linux 环境直接返回 `authentication/xiaoe_web_credential_unavailable`，不再启动无法回调的 localhost 登录。用户明确希望浏览器授权且宿主能够接收本地回调时，可以显式运行 `auth login`。
 
 脚本兼容链路会先自动发现桌面 XiaoE 客户端内置 Python（macOS 应用包与 Windows 按用户/全局安装均支持），再回退到系统 `python3`、`/usr/bin/python3`、`python`；Windows 的系统回退顺序为 `python`、`python3`、`py`。可用 `WEAVER_XIAOE_TOKEN_SCRIPT_PYTHON` 精确指定解释器，用 `WEAVER_XIAOE_TOKEN_SCRIPT_PATH` 指定桌面宿主脚本路径（旧名 `XIAOE_TOKEN_SCRIPT_PYTHON` / `XIAOE_TOKEN_SCRIPT_PATH` 仍兼容）。CLI 自带的 `xiaoe_env.py` 位于 npm 包 `scripts/`，不会放入 `weaver-e10-shared` Skill；Skill 包禁止携带或直接执行 Token 脚本。`XIAOE_` 是平台保留前缀，本 CLI 的自定义变量统一使用 `WEAVER_XIAOE_*`。
 
+上述“业务命令自动优先尝试”仅适用于当前智能体身份明确为 XiaoE 的进程。WorkBuddy、Codex 及其他智能体不会因为本机存在 XiaoE 文件或配置而进入该分支，并必须使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
+
 无法使用浏览器回调时，可以用 `auth set` 直接写入浏览器中复制到的
 `ETEAMSID`。命令会调用 `teamsCheck` 解析当前用户、租户和组织信息，并写入
 E10 兼容的 auth 文件。

package/package.json

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