weaver-work-cli 0.1.33 → 0.1.38

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

@@ -26,6 +26,7 @@ import { continuationReplayError } from '../continuation.js';
 import { writeStateFileBestEffort } from '../state.js';
 import { buildHistoryRequestData, fetchHistoryListSnapshot, filterHistoryRequestData, pickUniqueMineWorkflow, prefetchHistoryDetails } from './read.js';
 import { hasXiaoEEnv } from '../../../internal/e10/auth/xiaoe.js';
+import { createFetchTimingSink, runWithFetchTiming } from '../../../internal/e10/fetch-timing.js';
 import { buildChatSceneInput, formatLocalNow, requestFormFill } from './chatscene.js';
 // ---------------------------------------------------------------------------
 // 常量（与 Python 源逐条对齐）
@@ -592,7 +593,14 @@ function extractFields(layoutData, requiredMap, disableEditMap, displayMap) {
         // （Python 的 `bool({})` 为 False）——直接照抄 Python 的 `bool(browser_type)` 会让**每个字段**
         // 都被判成浏览按钮字段，文本/富文本字段随之走 name→ID 解析并报 BROWSER NOT_FOUND，
         // 内容永远写不进去（2026-09-16「内部留言」留言内容字段实证）。必须判"非空对象"。
-        const isBrowser = Object.keys(browserType).length > 0 || BROWSER_COMPONENTS.has(normalized);
+        // 组件名有两种写法：eBuilder 表单里常带 `Component` 后缀（`CustomerComponent` /
+        // `EmployeeComponent`），标准流程表单里是不带的（`customer` / `employee`）。
+        // ⛔ 只认前者会漏判：2026-10-31 会议申请流程的「参会客户」是 `CustomerComponent`，
+        // 被当成普通文本字段 ⇒ 提交 `[{id,name}]` 报「文本字段只接受字符串、数字或布尔值」。
+        const componentBase = normalized.replace(/component$/, '');
+        const isBrowser = Object.keys(browserType).length > 0
+            || BROWSER_COMPONENTS.has(normalized)
+            || BROWSER_COMPONENTS.has(componentBase);
         const isSelect = SELECT_COMPONENTS.has(normalized) || options.length > 0;
         result.push({
             id: fieldId,
@@ -1485,7 +1493,23 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
     // 澄清文案里回显的是**用户原话**（不是切分后的关键词）——用户要能认出自己给的条件
     const queryText = rawTerms.join('、');
     if (!rawTerms.length) {
-        throw workflowClarificationError('workflow', '', '要发起哪个流程？请提供该流程的完整名称（或其它可用于检索的关键词）后再继续。');
+        // ★ 2026-10-30 用户裁定：这一档不是「名称没匹配上」，而是**必填入参 `workflow` 根本没给**
+        // （缺键 / 空数组 / 空字符串都算）。原先与「只给了填充词」共用同一句澄清，模型看到的是
+        // 「请提供完整名称」，于是键名写错（如写成 `workflows`、`name`）时不知道自己漏了 `workflow`，
+        // 只会回头把锅甩给用户。现在单独标 `clarificationReason=workflow_required` 并下发
+        // `missingInput` + `requiredInput`，让模型知道「是我少传了入参、要按这个形态补」。
+        throw workflowClarificationError('workflow', '', '要发起哪个流程？请提供该流程的完整名称（或其它可用于检索的关键词）后再继续。', [], {
+            clarificationReason: 'workflow_required',
+            missingInput: ['workflow'],
+            requiredInput: {
+                workflow: {
+                    required: true,
+                    type: 'string | string[]',
+                    description: '要发起的工作流：完整名称、名称关键词，或「名称(ID)」；纯数字按工作流 ID 处理。',
+                    example: ['费用报销'],
+                },
+            },
+        });
     }
     // 先做**纯本地**的解析：显式 ID（`名称(ID)` / 纯数字）与名称关键词（一格可含多个，见
     // `splitCreateKeywords`）。这一步不依赖远端结果，于是能先判"到底有没有可用条件"——
@@ -1751,9 +1775,9 @@ function singleExplicitWorkflowId(rawWorkflow) {
     return parsed.id ?? (/^[0-9]+$/.test(terms[0]) ? terms[0] : '');
 }
 /** 表单载入 + 该工作流的记忆：两者只共享 `workflowId`，可以并行。 */
-async function loadCreateFormPack(workflowId, env) {
+async function loadCreateFormPack(workflowId, env, options = {}) {
     const [{ data }, workflowMemory] = await Promise.all([
-        buildCreateFormData(workflowId, env),
+        buildCreateFormData(workflowId, env, options),
         // 记忆读取是 best-effort（内部全 catch），不会把表单载入的错误顶掉。
         fetchWorkflowMemory(workflowId, env),
     ]);
@@ -1839,7 +1863,7 @@ async function resolveIntentFill(pack, userQuestion, baseUrl, env) {
  * 现在返回的就是纯取数结果：`fields` + `historyRequestData` + `systemFields` + 记忆，
  * 由模型自己拼 `data` 后交给 `createRequest`。
  */
-async function prepareCreateFormPayload(args, env) {
+async function prepareCreateFormPayload(args, env, options = {}) {
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
     // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
     //
@@ -1858,11 +1882,11 @@ async function prepareCreateFormPayload(args, env) {
         // `commonParam.authInfo` 给出；该 ID 不可用时由载入表单一侧的 `readCreateFormBlock`
         // 抛出**可判别**的澄清（不是把它伪装成"没有匹配到可发起的工作流"）。
         target = { id: explicitId, name: '', source: 'workflowId' };
-        pack = await loadCreateFormPack(explicitId, env);
+        pack = await loadCreateFormPack(explicitId, env, options);
     }
     else {
         target = await resolveCreateWorkflow(args.workflow, env);
-        pack = await loadCreateFormPack(target.id, env);
+        pack = await loadCreateFormPack(target.id, env, options);
     }
     // ★ 2026-10-15 用户裁定：`createForm` 改用**字符口径 20,000** 的**严格档**（见
     // `CREATE_FORM_STDOUT_SAFE_CHARS` / `compactFormOutput` 的 `charBudget`）。
@@ -1954,7 +1978,21 @@ async function commandCreateForm(args, env) {
  * 与旧版的差别只有一处：`workflowId` 由调用方（`resolveCreateWorkflow`）解析好后传进来，
  * 不再是本函数的入参校验点。
  */
-async function buildCreateFormData(workflowId, env) {
+async function buildCreateFormData(workflowId, env, options = {}) {
+    /**
+     * 明细字段的标记形态（2026-10-30 用户裁定）：
+     * - 缺省 `subFormId` —— `createForm` 口径，明细字段带 `subFormId`（`data.details` 的键）；
+     * - `isDetail` —— `createRequestDirect` 独有的口径，明细字段带 `isDetail: true`、不再下发 `subFormId`。
+     */
+    const detailMark = options.detailMark === 'isDetail' ? 'isDetail' : 'subFormId';
+    /**
+     * ★ 2026-10-30 用户裁定：`getHistory` 是 `createRequestDirect` 的**隐藏入参**（只在 CLI 实现层支持，
+     * 不进 `inputSchema`、不进 skill）。传 `false` 时「历史发起流程」这一段整块不做 ——
+     * 不发 `getMineListData`（列表）、不发明细，也不要组装；输出里 `historyRequestData` 直接给 `null`。
+     *
+     * 缺省（含 `createForm` 这一侧，它从不传）一律按 `true`，行为与从前一字不差。
+     */
+    const getHistory = options.getHistory !== false;
     const query = { workflowId, isCreate: 1, ...AJAX_QUERY };
     const body = { workflowId, isCreate: 1, isMobile: 0 };
     /**
@@ -1965,7 +2003,9 @@ async function buildCreateFormData(workflowId, env) {
      * `.catch(() => null)` 是必须的：这个 Promise 可能因为表单后续抛错而**没人 await**，
      * 兜住之后就不会留下未处理的拒绝；真要暴露的认证/网络错误由同批的载入请求抛出，不会被吞掉。
      */
-    const historyListSnapshot = fetchHistoryListSnapshot(env, { workflowId }).catch(() => null);
+    const historyListSnapshot = getHistory
+        ? fetchHistoryListSnapshot(env, { workflowId }).catch(() => null)
+        : Promise.resolve(null);
     /**
      * 明细请求紧跟着**列表**走（2026-10-29 用户口径）：它的入参只有 `requestId`（列表给的）与会话
      * `userId`，与 `getFormLayout` **没有任何参数依赖**；原先排在 layout 之后纯属写法问题，白等约
@@ -1976,7 +2016,9 @@ async function buildCreateFormData(workflowId, env) {
      * 空处理免得留下未处理的拒绝。真正的认证/网络错误仍由 `buildHistoryRequestData` 里那次 `await`
      * 决定去留（口径不变）。
      */
-    const historyDetails = historyListSnapshot.then(async (snapshot) => (snapshot && snapshot.requestIds.length ? prefetchHistoryDetails(env, snapshot) : null));
+    const historyDetails = getHistory
+        ? historyListSnapshot.then(async (snapshot) => (snapshot && snapshot.requestIds.length ? prefetchHistoryDetails(env, snapshot) : null))
+        : Promise.resolve(null);
     historyDetails.catch(() => { });
     // 2026-09-22：这四个接口**彼此没有数据依赖**（入参只需要 workflowId，见各自的 query/body），
     // 真机实测各 171–429 ms、串行合计约 1.1 s；并行后只受最慢的一个约束。
@@ -2105,6 +2147,31 @@ async function buildCreateFormData(workflowId, env) {
             continue;
         visibleFields.push(f);
     }
+    /**
+     * 明细表**整表被判不可见**时的显式告警（2026-10-31）。
+     *
+     * 场景：明细表被摆在了页面网格的**隐藏行 / 隐藏列**上（`pageLayouts[0].config.workbook.Sheet1.rows[n].visible=false`），
+     * 于是它的列字段全部被 `hiddenCellIds` 过滤掉。此前是**静默丢弃** —— 模型只看到"表单里没有这张明细表"，
+     * 分不清「表单确实没配」和「配了但摆在隐藏行上」，只能回一句"没有这张表"，用户无从下手。
+     * 这里按 subFormId 汇总，整表字段全灭的才告警（部分列隐藏属正常设计）。
+     */
+    const hiddenBySubform = new Map();
+    for (const f of fields) {
+        const fid = String(f.id ?? '');
+        const sid = String(f.subFormId ?? '').trim();
+        if (!sid || !hiddenCellIds.has(fid))
+            continue;
+        hiddenBySubform.set(sid, (hiddenBySubform.get(sid) || 0) + 1);
+    }
+    const survivingSubforms = new Set(visibleFields.map((f) => String(f.subFormId ?? '').trim()).filter(Boolean));
+    const invisibleSubformWarnings = [];
+    for (const [sid, count] of hiddenBySubform) {
+        if (survivingSubforms.has(sid))
+            continue;
+        invisibleSubformWarnings.push(`明细表 ${sid} 的 ${count} 个字段全部被判为「不可见」（该明细表所在的行/列在表单布局里是隐藏的），`
+            + '因此没有出现在字段清单里。要么在表单设计器里把明细表挪到可见行，要么取消隐藏它所在的行/列，然后重新载入表单。');
+    }
+    let layoutWarning = invisibleSubformWarnings.length ? invisibleSubformWarnings.join('；') : null;
     const defaults = normalizeDefaults(layoutData.defaultDetails);
     // 计算必填/可编辑/明细必填（按默认值 + onLoadForm 联动）
     const systemFieldValues = _normalizeSystemFieldValues(layoutData.businessOperatorObj);
@@ -2169,6 +2236,52 @@ async function buildCreateFormData(workflowId, env) {
         }
     }
     const folderOptionValues = _mainValueMap(defaults);
+    /**
+     * 「条件显示」的明细表（2026-10-31，会议申请流程「参会客户明细」实证）
+     *
+     * 表单可以给明细表配**显示联动**：触发字段有值时 `show`、为空时 `hideLine`。
+     * 会议申请流程的「参会客户明细」（subFormId `1332370499762806784`）就是这样 ——
+     * 触发字段是「参会客户」(`crm_members`)，空着时整表隐藏。
+     *
+     * 旧行为把它与「明细表被摆在隐藏行」一视同仁 ⇒ 整表字段从 `fields` 里消失，
+     * 建会链路既解析不到明细表也写不进明细，模型只能回「表单里没有这张表」。
+     * 现在：布局上确实存在、且有成对 `show` 规则的表，按**条件可见**处理 ——
+     * 字段照常下发（标 `conditional: true`），并在 `layoutWarning` 里说明触发字段。
+     */
+    const conditionalHiddenSubforms = new Set();
+    const conditionalMainFields = new Set();
+    const conditionalHints = collectDetailShowLinkages(layoutData.viewLinkages, fields);
+    /**
+     * 主表字段同理：「参会客户」(`crm_members`) 自己也有成对的 `show` / `hideLine` 规则
+     * （空值时连自己都隐藏）。若不这样处理，建会链路的 `crm_members` 永远映射不到字段。
+     */
+    const fieldShowIds = collectFieldShowLinkageIds(layoutData.viewLinkages);
+    for (const fid of Array.from(mainHidden)) {
+        if (!fieldShowIds.has(fid))
+            continue;
+        if (hiddenCellIds.has(fid))
+            continue;
+        const target = visibleFields.find((f) => String(f.id ?? '') === fid);
+        if (!target)
+            continue;
+        conditionalMainFields.add(fid);
+        mainHidden.delete(fid);
+        invisibleSubformWarnings.push(`字段「${target.name}」(${fid}) 因显示联动隐藏（该字段本身是触发字段），已照常下发并标 conditional: true`);
+    }
+    for (const sid of Array.from(hiddenSubforms)) {
+        const hint = conditionalHints.get(sid);
+        if (!hint)
+            continue;
+        const usable = visibleFields.some((f) => String(f.subFormId ?? '') === sid && !hiddenCellIds.has(String(f.id ?? '')));
+        if (!usable)
+            continue;
+        conditionalHiddenSubforms.add(sid);
+        hiddenSubforms.delete(sid);
+        invisibleSubformWarnings.push(`明细表 ${sid}${hint.tableName ? `（${hint.tableName}）` : ''} 因显示联动隐藏，触发字段：`
+            + `${hint.triggerNames.join('、') || hint.triggerIds.join('、')}。`
+            + '该表字段已照常下发（标 conditional: true），把触发字段填上后表单里就会显示；不要回「表单里没有这张明细表」。');
+    }
+    layoutWarning = invisibleSubformWarnings.length ? invisibleSubformWarnings.join('；') : null;
     for (const field of visibleFields) {
         const fieldId = String(field.id ?? '');
         const subFormId = String(field.subFormId ?? '');
@@ -2254,12 +2367,25 @@ async function buildCreateFormData(workflowId, env) {
         // 不在当前布局上的字段不下发——模型既填不了也看不到。
         if (!modelFieldIds.has(String(field.id ?? '')))
             continue;
-        // 键序 id|name|subFormId|componentKey 是契约；`subFormId` **为空就整个省略**（缺该键＝主表字段）
-        // —— 主表字段占绝大多数，写 `""` 恒白占一条键（真机 278 字段表单：100 个主表字段 × 22 B ≈ 2.2 KB）。
+        // 明细标记**按命令分档**（2026-10-30 用户裁定：改成 isDetail 只对 `createRequestDirect` 生效）：
+        // - `createRequestDirect`：键序 `id|name|isDetail|componentKey`，明细字段带 `isDetail: true`，
+        //   主表字段**整个省略**该键（缺键＝主表；恒写 `isDetail:false` 白占体积），且**不下发** `subFormId`；
+        // - `createForm`（默认档）：维持原口径，明细字段带 `subFormId`（它就是 `data.details` 的键），
+        //   主表字段省略该键。
         const slimSubFormId = String(field.subFormId ?? '');
         const item = { id: field.id, name: field.name };
-        if (slimSubFormId)
+        if (detailMark === 'isDetail') {
+            if (slimSubFormId)
+                item.isDetail = true;
+        }
+        else if (slimSubFormId) {
             item.subFormId = slimSubFormId;
+        }
+        // 条件可见的明细表（见 conditionalHiddenSubforms 注释）：字段可用，但当前触发字段没值时表单里不显示。
+        if (slimSubFormId && conditionalHiddenSubforms.has(slimSubFormId))
+            item.conditional = true;
+        if (!slimSubFormId && conditionalMainFields.has(String(field.id ?? '')))
+            item.conditional = true;
         item.componentKey = field.componentKey;
         // 表单初始化时就有的值（OA 预填 + onLoadForm 联动带出）——有才出现该键；**没有默认值的字段不带**。
         // CLI 拼 `data` 时会自动并入，模型**不必显式传**；用户本次明确改写了它才按用户说的覆盖（见
@@ -2335,7 +2461,7 @@ async function buildCreateFormData(workflowId, env) {
             ...requiredFieldsList.map((f) => String(f?.id ?? '')),
             ...Object.values(subFormRequired).flatMap((list) => list.map((f) => String(f?.id ?? ''))),
         ].filter(Boolean))];
-    const historyCache = fields.length
+    const historyCache = getHistory && fields.length
         ? await buildHistoryRequestData(env, fields, historyRequiredFieldIds.map((id) => ({ id, name: String((fieldsById.get(id) || {}).name ?? id) })), { allFormFields: true, workflowId }, 
         // 本命令开头就已并发发起的列表请求：这里只补「详情」那几步（P2）。
         historyListSnapshot, 
@@ -2407,7 +2533,9 @@ async function buildCreateFormData(workflowId, env) {
             // 历史参考值（近一年、非草稿、最近 5 条「我发起的」）——填值前先看它，能直接照用的字段就别去
             // 问用户。字段范围与 `fields` **同一口径**（见 modelFieldIds 注释）；完整结果（本表单全部字段）
             // 仍随句柄留给 `createRequest` 用（条件必填要到那边才现身）。
-            historyRequestData: filterHistoryRequestData(historyCache, modelFieldIds),
+            // `getHistory:false`（隐藏入参）时整段历史取数没做 ⇒ 这里给 `null`（不是空数组：空数组表示
+            // "查了但没数据"，两者含义不同）。
+            historyRequestData: getHistory ? filterHistoryRequestData(historyCache, modelFieldIds) : null,
             systemFields: {
                 permissions: minorInfo.permissions || {},
                 defaults: context.systemFields.defaults,
@@ -2416,6 +2544,8 @@ async function buildCreateFormData(workflowId, env) {
             },
             systemFieldWarning: minorWarning,
             requiredInfoWarning: requiredInfoWarningText(context),
+            // 明细表整表不可见时的告警（见 layoutWarning 注释）：有值时**不要**回"表单里没有这张明细表"。
+            layoutWarning,
             // 原 Python 把完整 context 落盘；此处通过 continuation 承载，返回结构保持文档契约。
             continuation: token,
         },
@@ -3821,9 +3951,11 @@ async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdi
     }
     if (!dataList.length && !runDataList.length)
         return [];
+    // 建模表单的联动接口 `module` 是 `ebuilderform`（与布局 / 保存的 `ebuildercard` 不同，真机请求体实证）。
+    const linkageModule = formModuleName(ctx.frame && ctx.frame.relate_type, 'ebuilderform');
     const executeParam = {
         formId: ctx.layout.form_id,
-        module: 'workflow',
+        module: linkageModule,
         dataList,
         runDataList,
         moduleDataList: [],
@@ -3867,9 +3999,10 @@ async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdi
         if (frame.layout_multi_id)
             executeParam.layoutId = frame.layout_multi_id;
     }
-    const payload = { formId: ctx.layout.form_id, module: 'workflow', executeParam };
+    const payload = { formId: ctx.layout.form_id, module: linkageModule, executeParam };
     const relateType = (ctx.frame && ctx.frame.relate_type) || '';
-    const endpoint = formApiUrl(FORM_ENDPOINTS.fdLinkage, relateType);
+    // 建模表单的联动接口在 `/api/ebuilder/form/` 下，与布局 / 保存的 `/api/ebuilder/flow/` 不同（真机实证）。
+    const endpoint = formApiUrl(FORM_ENDPOINTS.fdLinkage, relateType, '/api/ebuilder/form/');
     const response = await requestJson(env, 'POST', endpoint, AJAX_QUERY, payload);
     // requestJson 内部已解包一层（responseData），此处不可再取 .data
     const data = (response && typeof response === 'object') ? response : null;
@@ -3914,6 +4047,74 @@ function mergeLinkageDetails(merged, linkageDetails) {
 function emptyLinkageVisibility() {
     return [new Set(), {}, {}, {}];
 }
+/**
+ * 收集主表字段的 `show` 联动字段 id（`linkageObj=field` 且 `linkageProp=show`）。
+ * 这类字段的隐藏是**条件性**的，按条件可见处理，见 `buildCreateFormData` 的 `conditionalMainFields`。
+ */
+export function collectFieldShowLinkageIds(linkages) {
+    const out = new Set();
+    if (!Array.isArray(linkages))
+        return out;
+    for (const rule of linkages) {
+        const details = Array.isArray(rule?.linkageDetails) ? rule.linkageDetails : [];
+        for (const detail of details) {
+            if (!detail || typeof detail !== 'object')
+                continue;
+            if (String(detail.linkageObj ?? '') !== 'field')
+                continue;
+            if (String(detail.linkageProp ?? '') !== 'show')
+                continue;
+            const fid = String(detail.linkageValue ?? '').trim();
+            if (fid)
+                out.add(fid);
+        }
+    }
+    return out;
+}
+/**
+ * 收集「明细表的显示联动」——`linkageObj=detail` 且 `linkageProp=show` 的规则。
+ *
+ * 用途见 `buildCreateFormData` 里 `conditionalHiddenSubforms` 的注释：配了 `show` 规则的明细表
+ * 是**条件可见**（另有配套的 `hideLine` 规则），不能因为当期条件不成立就把整表字段丢掉。
+ * 返回 `subFormId → { triggerIds, triggerNames, tableName }`，triggerNames 供告警文本直接引用。
+ */
+export function collectDetailShowLinkages(linkages, fields) {
+    const out = new Map();
+    if (!Array.isArray(linkages))
+        return out;
+    const list = Array.isArray(fields) ? fields : [];
+    const nameOf = (id) => {
+        for (const f of list) {
+            if (String(f?.id ?? '') === id)
+                return String(f?.name ?? id);
+        }
+        return id;
+    };
+    for (const rule of linkages) {
+        const details = Array.isArray(rule?.linkageDetails) ? rule.linkageDetails : [];
+        for (const detail of details) {
+            if (!detail || typeof detail !== 'object')
+                continue;
+            if (String(detail.linkageObj ?? '') !== 'detail')
+                continue;
+            if (String(detail.linkageProp ?? '') !== 'show')
+                continue;
+            const sid = String(detail.linkageValue ?? '').trim();
+            if (!sid)
+                continue;
+            const conds = Array.isArray(rule?.condition?.conditionDetails) ? rule.condition.conditionDetails : [];
+            const triggerIds = conds
+                .map((c) => String(c?.targetId ?? '').trim())
+                .filter(Boolean);
+            out.set(sid, {
+                triggerIds,
+                triggerNames: triggerIds.map(nameOf),
+                tableName: nameOf(sid) === sid ? '' : nameOf(sid),
+            });
+        }
+    }
+    return out;
+}
 function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, systemFieldValues, fields) {
     const hiddenSubforms = new Set();
     const rowHidden = {};
@@ -4646,6 +4847,8 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
  *   的就是与普通链路同一段代码），它们不是必填判定。
  * - 句柄**不消费**：本分支在任何写请求之前返回，同一个 `context` 之后仍可正常重发。
  * - `title` 取**工作流名称**；`src` 与两处 `routerProps_*` 的 `initialEntries` 用**工作流 id**；
+ *   `src` 末尾另按 `&<字段id>=<值>` 拼上本次要填的字段（2026-10-30 用户裁定，与下面
+ *   `params.customParams` 同一份数据）；
  *   `params.customParams` 取 `createRequest` **入参**经解析后的字段值（不含表单默认值、不含联动带出的值），
  *   同段 `fieldAssignKeys` 列出这次要填的**全部字段 id**（`,` 连接）。
  */
@@ -4798,10 +5001,31 @@ function xiaoECustomParams(preview) {
     }
     return { values, keys: ordered };
 }
+/**
+ * `src` 末尾的字段参数（2026-10-30 用户裁定）：`&<字段id>=<值>`，与 `params.customParams` 里那份
+ * 字段值**同一份数据、同一顺序**（`fieldAssignKeys` 是元信息，不进 URL）。
+ *
+ * 值**原样拼、不做任何百分号编码**：客户端自己解析这段 query（按 `&` 切键值对、再按 `=` 切第一个
+ * 等号），中文、空格、`,` / `;` / `#` 等都不需要转义，拼出来的字面值必须与 `params.customParams`
+ * 里逐字相同。唯一代价是值本身含 `&` 时会截断——按用户口径以此为准，不在此处兜底改写。
+ */
+function xiaoESrcFieldQuery(params) {
+    let query = '';
+    for (const fieldId of params.keys) {
+        const text = params.values[fieldId];
+        if (!text)
+            continue;
+        query += `&${fieldId}=${text}`;
+    }
+    return query;
+}
 /**
  * 渲染 `<browsertool>` 块（该块**整体**就是小e 环境下 `createRequest` 的 `finalMarkdown`）。
  *
  * 除 `title` / `src` / 两处 `routerProps_*` 的 `initialEntries` / `params.customParams` 外全部写死。
+ *
+ * `src` 形如 `…/flowpage/create/<workflowId>?workflowId=<workflowId>&isCreate=1&<字段id>=<值>&…`
+ * —— 末尾的字段参数与 `params.customParams` 同源（2026-10-30 用户裁定）。
  */
 function renderXiaoEFillFormMarkdown(params) {
     const base = String(params.baseUrl ?? '').replace(/\/+$/u, '');
@@ -4814,7 +5038,7 @@ function renderXiaoEFillFormMarkdown(params) {
         arguments: {
             type: 'e10',
             title: String(params.title ?? ''),
-            src: `${base}/sp/workflow${createPath}?workflowId=${workflowId}&isCreate=1`,
+            src: `${base}/sp/workflow${createPath}?workflowId=${workflowId}&isCreate=1${xiaoESrcFieldQuery(params.customParams)}`,
             sdkOptions: {
                 compName: XIAOE_FILL_FORM_SDK_OPTIONS.compName,
                 routerType: XIAOE_FILL_FORM_SDK_OPTIONS.routerType,
@@ -4840,7 +5064,8 @@ function renderXiaoEFillFormMarkdown(params) {
  * - `durationMs` = 命令入口 → 结果产出；
  * - `apiDurations` = 每个接口（并行批次合成一个 key，取墙钟、不叠加）；
  * - `apiSlowest` = 每个**真并行**批里谁最慢（`[{ batch, name, ms, items }]`，`ms` 是该接口自身耗时，
- *   `items` 是批内每个成员的 `{ name, at, ms }`，按 `ms` 降序）；
+ *   `items` 是批内每个成员的 `{ name, at, ms, fetchAt, fetchEnd, fetchCost }`，按 `ms` 降序；
+ *   `fetchAt`/`fetchEnd`/`fetchCost` 描述其中纯 fetch 那一段）；
  * - `authMs` = 登录取凭据（首次会话解析）的墙钟 —— 这一段走 auth 层自己的 fetch、不经
  *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账。
  *
@@ -4995,7 +5220,12 @@ async function runCreateRequest(args, env, options = {}) {
      * （`buildCreateFormData`，那边的联动结果要用来算字段的必填 / 可编辑清单）；这里两者都不跑 ——
      * 本档既不做必填判定、也不发写请求。非小e 环境行为不变。
      */
-    const isXiaoE = hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
+    // ⛔ 2026-10-31 真机回归：调用方可以显式要求「小e 环境也走服务端提交」（meeting 建会直提用）。
+    // 起因：小e 的浏览器填单页只给**文本类**字段赋值，浏览按钮（参会人员 / 参会客户）传过去整段是空 ——
+    // 用户看到的就是"填了但表单里这两个字段没有值"。服务端提交这条路上这些字段走标准 JSON，
+    // 能完整落库，所以建会这类「字段必须完整」的场景应走直提，浏览器填单只留给需要人工核对/补填的场合。
+    const forceServerSubmit = args.forceServerSubmit === true;
+    const isXiaoE = forceServerSubmit ? false : hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
     const linkageDetails = isXiaoE
         ? []
         : await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false, context.defaults || []);
@@ -5469,15 +5699,27 @@ function apiShortName(path) {
  * 给 host 套一层**逐接口计时**（只包请求，不改返回、不吞异常）。
  *
  * `finally` 里落片段：请求失败（超时 / 业务错误 / 抛错）同样要记 —— 恰恰是这类请求最需要看到耗时。
+ *
+ * 片段里除整段耗时外，还记**纯 fetch** 那一段（`fetchMs`，2026-10-30 用户要求）：它由
+ * `runWithFetchTiming` 开一个旁路 sink、`E10RequestRuntime` 在 fetch 前后各打一枪得到，
+ * 两条链路都只读不改请求/返回值。
  */
 function withApiTiming(host, spans) {
     const record = async (path, run) => {
         const start = Date.now();
+        const fetchTiming = createFetchTimingSink();
         try {
-            return await run();
+            return await runWithFetchTiming(fetchTiming, run);
         }
         finally {
-            spans.push({ name: apiShortName(path), start, end: Date.now() });
+            spans.push({
+                name: apiShortName(path),
+                start,
+                end: Date.now(),
+                fetchStart: fetchTiming.fetchStart,
+                fetchEnd: fetchTiming.fetchEnd,
+                fetchMs: fetchTiming.fetchMs,
+            });
         }
     };
     return {
@@ -5506,7 +5748,9 @@ function withApiTiming(host, spans) {
  * - 批内**全是同一个接口**时也不产（如 5 个并发的 `getWorkflowRequest` 取历史详情）：请求都一样，
  *   "谁最慢"没有区分意义，只有批的墙钟有用（2026-10-22 用户第二轮裁定）；
  * - `ms` 取该接口**自身**耗时（`end - start`），不是批墙钟；
- * - 每条另带 `items`：批内**每个**成员的 `{name, at, ms}`（`at` 相对批起点），按 `ms` 降序。
+ * - 每条另带 `items`：批内**每个**成员的 `{name, at, ms, fetchAt, fetchEnd, fetchCost}`（`at` 相对批
+ *   起点；`ms` 自身耗时；`fetchAt`/`fetchEnd` 是其中**纯 fetch**（发出请求 → 收到响应头）的起止偏移、
+ *   `fetchCost` 是它的耗时，2026-10-30 用户要求），按 `ms` 降序。
  *   2026-10-26 用户要求：只看最慢项判断不出「优化它值不值」——若批内多个接口耗时接近，
  *   砍掉最慢那个的收益有限，得看整条关键路径的分布；
  * - 顺序＝批的时间顺序，与 `apiDurations` 的 key 一一对应。
@@ -5541,13 +5785,17 @@ function summarizeApiSpans(spans) {
         // 批内全是同一个接口 ⇒ 不产最慢项（"5 个 getWorkflowRequest 里谁最慢"没有区分意义）。
         if (group.length > 1 && new Set(names).size > 1) {
             const origin = Math.min(...group.map((item) => item.start));
-            // 批内逐个成员都留一条（`at` 相对批起点，`ms` 自身耗时），按耗时降序；并列取先开始的
-            // （`at` 升序），保证同一份输入每次输出一致。`name`/`ms` 就取这一项。
+            // 批内逐个成员都留一条（`at` 相对批起点，`ms` 自身耗时；`fetchAt`/`fetchEnd` 是其中纯 fetch
+            // 的起止偏移、`fetchCost` 是它自身的耗时），按耗时降序；并列取先开始的（`at` 升序），
+            // 保证同一份输入每次输出一致。`name`/`ms` 就取这一项。
             const items = group
                 .map((item) => ({
                 name: item.name,
                 at: Math.max(0, Math.round(item.start - origin)),
                 ms: Math.max(0, Math.round(item.end - item.start)),
+                fetchAt: item.fetchStart === null ? null : Math.max(0, Math.round(item.fetchStart - origin)),
+                fetchEnd: item.fetchEnd === null ? null : Math.max(0, Math.round(item.fetchEnd - origin)),
+                fetchCost: Math.max(0, Math.round(item.fetchMs)),
             }))
                 .sort((a, b) => (b.ms - a.ms) || (a.at - b.at));
             slowest.push({ batch: key, name: items[0].name, ms: items[0].ms, items });
@@ -5555,6 +5803,26 @@ function summarizeApiSpans(spans) {
     }
     return { durations, slowest };
 }
+/**
+ * `createRequestDirect` 的**隐藏入参** `getHistory` 取值（2026-10-30 用户裁定）。
+ *
+ * 只在 CLI 实现层支持：**不写进** `inputSchema`、不写进 skill 文档，模型侧看不到、也没法从
+ * `workflow schema` 里读到；需要时由调用方（桌面端 / 脚本）自己塞进 `--input-json`。
+ *
+ * 口径：缺省、`null`、`undefined`、空串、其它非 `false` 的真值 ⇒ `true`（与从前的行为完全一致）；
+ * 只有明确表达"不要"的写法才关掉：`false` / `0` / `"false"` / `"0"`（大小写、首尾空格都不敏感）。
+ * 宽松接受字符串是为了调用方从环境变量或配置里透传时不必先转类型。
+ */
+function readHiddenGetHistory(value) {
+    if (value === false || value === 0)
+        return false;
+    if (typeof value === 'string') {
+        const text = value.trim().toLowerCase();
+        if (text === 'false' || text === '0')
+            return false;
+    }
+    return true;
+}
 /**
  * `workflow.createRequestDirect` —— **取数命令**（2026-10-22 用户裁定，语义已变）。
  *
@@ -5576,6 +5844,10 @@ function summarizeApiSpans(spans) {
  * 5. **输出降级**（按 20,000 **字符**，与 `createForm` 同一个宿主口径）：
  *    全量超线 ⇒ `historyRequestData` 留空数组（键还在）；仍超 ⇒ `userMemory` 留空串（键还在；小e 档没有
  *    这个键，不补）；**`fields` 自己也超线时不再裁**（宁大不丢）—— 它是唯一不可省的，砍了这条命令就没有意义。
+ * 6. **隐藏入参 `getHistory`**（2026-10-30 用户裁定）：只在实现层支持，**不进 schema、不进 skill**。
+ *    不传 = `true`（原行为）；传 `false` 时整段「历史发起流程」取数（`getMineListData` 列表 + 明细）
+ *    一次都不发，输出里 `historyRequestData` 直接是 `null`（不是空数组——空数组的意思是"查了但没数据"）。
+ *    这一档也不参与上面的输出降级。
  *
  * ## 耗时
  * 与 `createForm` 完全同口径，全部收在 `timing` 一个桶里：`durationMs`（整条命令）/
@@ -5588,9 +5860,15 @@ async function commandCreateRequestDirect(args, env) {
     // 计时从**命令入口**开始算（含会话解析、工作流消歧、表单载入）。
     const spans = [];
     const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    // 隐藏入参（不进 schema / skill）：`false` 时不跑「历史发起流程」那段取数。
+    const getHistory = readHiddenGetHistory(args.getHistory);
     // 取数段本身已经不碰 `chatScene`（`createForm` 自 2026-10-23 起不再接 `userQuestion`），
-    // 这里不必再置空任何入参。
-    const { payload, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    // 这里不必再置空任何入参。`detailMark` 也是**本命令独有**：明细字段标 `isDetail: true`、
+    // 不再下发 `subFormId`（`createForm` 仍走老口径，见 `buildCreateFormData`）。
+    const { payload, authMs } = await prepareCreateFormPayload(args, timedEnv, {
+        getHistory,
+        detailMark: 'isDetail',
+    });
     const contextId = String(payload.contextId ?? '');
     if (!contextId) {
         // `prepareCreateFormPayload` 正常返回时 contextId 必然存在；这里只用来判断
@@ -5625,8 +5903,10 @@ async function commandCreateRequestDirect(args, env) {
     const overLine = () => finalStdoutChars({ ...data, ...reserve }, 'workflow.createRequestDirect') > CREATE_FORM_STDOUT_SAFE_CHARS;
     // 两级降级：先砍历史（留空 key）→ 再砍记忆（留空 key）。`fields` 不参与裁剪。
     // 小e 档没有 `userMemory` 这个键，第二级跳过（不能借"写空串"把它重新加回来）。
+    // `getHistory:false` 时历史那一档本来就没查（值是 `null`）⇒ 不参与降级，否则会把"没查"说成"查了没数据"。
     if (overLine()) {
-        data.historyRequestData = [];
+        if (getHistory)
+            data.historyRequestData = [];
         if ('userMemory' in data && overLine())
             data.userMemory = '';
     }
@@ -5649,10 +5929,30 @@ function formatRemark(value) {
         return text;
     return `_weaverMte_<p>${text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</p>`;
 }
+/**
+ * 表单所属模块名：建模表单（`relateType=WEA_EBUILDER`）按接口取自己的 service 名，其余是 `workflow`。
+ *
+ * 服务端按请求体里的 `module` 解析 `@Service("<module>_FormCoreService")`：建模表单传 `workflow`
+ * 会直接 500「未找到名为 FormCoreService 的实例对象」（2026-10-29 e-cology 建模流程实测：只把该值
+ * 改成 `ebuildercard` 即 200）。所以凡是请求体带 `module` 的表单接口（布局 / 附件 / 保存 / 联动）
+ * 都必须按表单类型取值，不能硬编码。
+ *
+ * ⚠️ 建模表单内部**不是同一个值**，必须按接口分别给（均为真机请求体实证）：
+ * - `getFormLayout` / `saveFormData` / 附件上传 → `ebuildercard`
+ * - `executeFdLinkage` / `getFormDataAndLayout` → `ebuilderform`
+ *
+ * 注意这两个值**不按目录/同族划分**：`getFormDataAndLayout` 与 `getFormLayout` 同在 `form/core` 下，
+ * 前者是 `ebuilderform`、后者是 `ebuildercard`。所以只能按接口真机样例取值，不能靠推断。
+ */
+function formModuleName(relateType, ebModule = 'ebuildercard') {
+    return String(relateType ?? '').trim() === 'WEA_EBUILDER' ? ebModule : 'workflow';
+}
 function buildSaveBody(context, prepared) {
     const runtime = context.runtime;
+    // 顶层 `module` 与 `formData.module` 是同一条判据：建模表单的 saveFormData 也走 ebuilder 的服务。
+    const moduleName = formModuleName(context.frame?.relate_type);
     return {
-        module: 'workflow',
+        module: moduleName,
         customParam: {
             isCreate: true,
             requestId: runtime.request_id,
@@ -5670,7 +5970,7 @@ function buildSaveBody(context, prepared) {
         },
         employeeId: runtime.employee_id,
         formData: {
-            module: 'workflow',
+            module: moduleName,
             presetDataId: runtime.request_id,
             dataDetails: prepared.dataDetails,
             client: 'pc',
@@ -6171,12 +6471,15 @@ async function runCreateNodeFieldVerification(env, context, switches) {
 // ---------------------------------------------------------------------------
 // editLoad / editPrepare / editSave
 // ---------------------------------------------------------------------------
-function buildEditDataLayoutRequest(requestId, workflowId, nodeId, formId, dataId, layoutMultiId, viewFormNodeId, permissionType, runtime) {
+function buildEditDataLayoutRequest(requestId, workflowId, nodeId, formId, dataId, layoutMultiId, viewFormNodeId, permissionType, runtime, relateType) {
     return {
         terminalType: 'PC',
         dataId,
         formId,
-        module: 'workflow',
+        // 建模表单取 `ebuilderform`（2026-10-30 真机请求体实证），**不是** `ebuildercard`：
+        // 同为 `form/core` 下的接口，`getFormLayout` / `saveFormData` 是 `ebuildercard`，
+        // 本接口与 `executeFdLinkage` 是 `ebuilderform` —— 建模表单内部不能按"同族"推定。
+        module: formModuleName(relateType, 'ebuilderform'),
         newLayout: true,
         cacheUid: null,
         layoutMultiId,
@@ -6250,7 +6553,7 @@ async function commandEditLoad(args, env) {
         tenantSetting = {};
     }
     const dataId = requestId;
-    const dlResp = await requestJson(env, 'POST', formApiUrl(FORM_ENDPOINTS.formDataAndLayout, frame.relate_type), { formId: frame.form_id, dataId, ...AJAX_QUERY }, buildEditDataLayoutRequest(requestId, workflowId, runtime.node_id, frame.form_id, dataId, frame.layout_multi_id, frame.view_form_node_id, frame.permission_type, runtime));
+    const dlResp = await requestJson(env, 'POST', formApiUrl(FORM_ENDPOINTS.formDataAndLayout, frame.relate_type), { formId: frame.form_id, dataId, ...AJAX_QUERY }, buildEditDataLayoutRequest(requestId, workflowId, runtime.node_id, frame.form_id, dataId, frame.layout_multi_id, frame.view_form_node_id, frame.permission_type, runtime, frame.relate_type));
     const dlData = dlResp;
     if (!dlData || typeof dlData !== 'object')
         throw workflowApiError('format_error', 'getFormDataAndLayout 未返回有效 data');
@@ -6558,8 +6861,10 @@ async function commandEditPrepare(args, env) {
 }
 function buildEditSaveBody(context, prepared) {
     const runtime = context.runtime || {};
+    // 同 `buildSaveBody`：改已有表单时也按表单类型取 module，建模表单要 `ebuildercard`。
+    const moduleName = formModuleName(context.frame?.relate_type);
     return {
-        module: 'workflow',
+        module: moduleName,
         customParam: {
             isCreate: false,
             requestId: context.requestId ?? context.request_id,
@@ -6579,7 +6884,7 @@ function buildEditSaveBody(context, prepared) {
         formData: {
             id: context.data_id,
             updateTimeStamp: context.update_time_stamp || '',
-            module: 'workflow',
+            module: moduleName,
             dataDelRows: [],
             dataDetails: prepared.dataDetails || [],
             client: 'pc',