weaver-work-cli 0.1.23 → 0.1.25

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,383 @@ 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)`）。两处必须同步修改。
+ *
+ * ★ 2026-10-14 补齐 `dataText` 候选（此前只存在于 `detailFormFieldValue`，两边口径**并不一致**）：
+ * `TextArea` 类字段（真机 `报销事由`）的值在 detail 响应里是 `dataText: {content/richContent/…}`，
+ * 只有详情面板分支认得它 ⇒ 历史参考值恒缺这一类字段（真机实证：同一条历史流程，
+ * 详情面板解出 50 个字段、历史取值只有 49 个，差的正好是唯一的必填 `TextArea` 字段
+ * `报销事由`，其值 `2026-08…`）。这里返回**已抽出的展示文本**（与详情面板同口径），
+ * 调用方的 `formatHistoryFieldValue` 仍会按字段类型二次格式化。
+ */
+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;
+    const dataText = obj?.dataText;
+    if (dataText && typeof dataText === 'object') {
+        const text = stringifyDetailDataText(dataText);
+        if (text)
+            return text;
+    }
+    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);
+}
+/**
+ * 历史取数的**前半段**：只发那一次列表请求。
+ *
+ * 与 `buildHistoryRequestData` 拆开的原因（P2 提速，2026-10-13）：这一步**只依赖 `workflowId`**，
+ * 不需要任何表单字段 ⇒ 可以和 `loadBaseParam` / `loadFrameParam` / `loadMinorInfo` / `getFormLayout`
+ * 一起**并发发起**，不再排在这些载入之后的串行尾巴上（真机该请求约 1–2 s，落在关键路径上纯亏）。
+ *
+ * 失败口径与整体一致：一律降级为 `null`（`rethrowAuthOrNetworkError` 仍会把认证/网络类错误抛出去，
+ * 由调用方决定；调用方若走"预取 + 复用"的形态，必须在预取处 `.catch(() => null)` 兜住，
+ * 避免出现无人 `await` 的未处理拒绝——真正需要暴露的认证错误由同批的载入请求抛出，不会因此被吞掉）。
+ */
+export async function fetchHistoryListSnapshot(env, options = {}) {
+    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;
+        return { items, requestIds };
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return null;
+    }
+}
+export async function buildHistoryRequestData(env, fields, targets, options = {}, 
+/**
+ * 已提前发起的列表请求（见 `fetchHistoryListSnapshot`）。传入即直接复用，不再重复发请求；
+ * 传 `null` / 不传时退回"本函数内自己发列表"的老口径。
+ */
+prefetchedList) {
+    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);
+    try {
+        const listed = prefetchedList
+            ? await prefetchedList
+            : await fetchHistoryListSnapshot(env, options);
+        if (!listed)
+            return null;
+        const items = listed.items;
+        const requestIds = listed.requestIds;
+        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);
+            // 键序 = `orderedIds`（本表单布局顺序）的插入顺序；同一字段只留**首个**取到值的结果。
+            const fieldValues = {};
+            for (const fieldId of orderedIds) {
+                const raw = rawById.get(fieldId);
+                if (raw === undefined || raw === null)
+                    continue;
+                if (Object.prototype.hasOwnProperty.call(fieldValues, fieldId))
+                    continue;
+                const value = formatHistoryFieldValue(raw, fieldMeta.get(fieldId));
+                // 附件类返回的是对象 ⇒ 不能再用 `String(value).trim()` 判空（那会得到 "[object Object]"）。
+                if (isEmptyRawFieldValue(value))
+                    continue;
+                fieldValues[fieldId] = value;
+            }
+            if (!Object.keys(fieldValues).length)
+                continue;
+            const base = data.workflowBaseInfo && typeof data.workflowBaseInfo === 'object' ? data.workflowBaseInfo : {};
+            const listedItem = items[index] || {};
+            result.push({
+                requestName: pickText(base, 'requestName', 'requestNameTitle')
+                    || String(listedItem.flowName ?? ''),
+                requestId: requestIds[index],
+                createdatetime: 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 source = record.fieldValues;
+        if (!source || typeof source !== 'object' || Array.isArray(source))
+            continue;
+        // 保留原键序，只留下本次要看的字段（口径见函数注释）。
+        const fieldValues = {};
+        for (const fieldId of Object.keys(source)) {
+            if (wanted.has(fieldId))
+                fieldValues[fieldId] = source[fieldId];
+        }
+        if (!Object.keys(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

@@ -1,4 +1,5 @@
 import { WorkflowCliError, workflowValidationError } from '../errors.js';
+import { stringifyForStdout } from '../../../core/output.js';
 /**
  * 模型输入中永远不允许出现的键。
  *
@@ -181,6 +182,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;
 /** 结果序列化后的字节数（**压缩**口径，用作相对大小参考）。 */
@@ -209,3 +213,27 @@ export function stdoutBytesOf(value) {
         return 0;
     }
 }
+/**
+ * 宿主**实际看到**的 stdout 字符数 —— 与 `Output.write` 真正打出去的那份文本**同源**
+ * （同一条 `stringifyForStdout` + 同一套紧凑路径），而不是"美化 JSON 长度的近似值"。
+ *
+ * ★ 判线必须与最终输出同源。2026-10-15 之前量的是 `JSON.stringify(value, null, 2).length`（纯美化），
+ * 而紧凑路径会把 `fields` / `historyRequestData` / `systemFields` 的缩进空白整段压掉 —— 实测
+ * `createForm` 整份小约 **30%**（`hugeLayout(120)` 桩：23,522 → 16,613 字符），那份桩因此从
+ * 「超线落盘」翻成「内联返回」。两份数一旦脱钩，判线就**系统性高估**：本可内联的表单被判落盘。
+ * 而宿主侧的线（`terminal_tool.py` 的 `MAX_OUTPUT_LEN = 20000`）量的是**最终输出文本**的 `len()`，
+ * 它并不关心美化不美化。
+ *
+ * `compactPaths` 从**信封根**算起（如 `data.fields`）；不传即按无紧凑路径量（等价于纯美化）。
+ * 其余命令仍用 `stdoutBytesOf()` 的**字节**口径 —— 两个口径对纯 ASCII 一致、对中文差 3 倍
+ * （1 字符 / 3 字节），**用哪个必须跟着阈值走**，不可混用。
+ */
+export function stdoutCharsOf(value, compactPaths) {
+    try {
+        const text = stringifyForStdout(value, compactPaths);
+        return typeof text === 'string' ? text.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}

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
-            ? '当前没有任何候选——请让用户给出准确的完整名称（或纠正名称里的错别字）后重发。'
+            ? '当前没有任何候选——请让用户给出该对象的完整名称（或纠正名称里的错别字、换其它可用于检索的关键词）后重发。'
             : '');
 }
 /**