weaver-work-cli 0.1.24 → 0.1.26

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

@@ -17,12 +17,16 @@
  */
 import { randomUUID } from 'node:crypto';
 import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CONTINUATION, SCHEMA_CONFIRM, } from './types.js';
-import { asBool, responseData, toArray, withLeadingMeta, stdoutBytesOf, STDOUT_SAFE_BYTES, parseNameWithId, resolveMemoryAppId, } from './shared.js';
+import { asBool, responseData, toArray, withLeadingMeta, stdoutBytesOf, stdoutCharsOf, STDOUT_SAFE_BYTES, parseNameWithId, resolveMemoryAppId, } from './shared.js';
 import { workflowValidationError, workflowApiError, workflowPartialError, workflowPolicyError, workflowClarificationError, WorkflowCliError, } from '../errors.js';
 import { FORM_ENDPOINTS, WORKFLOW_ENDPOINTS, AJAX_QUERY, formApiUrl } from '../endpoints.js';
+import { resolveSignRemark } from './sign-input.js';
+import { compactStdoutPaths } from '../stdout-compact.js';
 import { continuationReplayError } from '../continuation.js';
 import { writeStateFileBestEffort } from '../state.js';
-import { buildHistoryRequestData, filterHistoryRequestData } from './read.js';
+import { buildHistoryRequestData, fetchHistoryListSnapshot, filterHistoryRequestData, pickUniqueMineWorkflow } from './read.js';
+import { hasXiaoEEnv } from '../../../internal/e10/auth/xiaoe.js';
+import { buildChatSceneInput, formatLocalNow, requestFormFill } from './chatscene.js';
 // ---------------------------------------------------------------------------
 // 常量（与 Python 源逐条对齐）
 // ---------------------------------------------------------------------------
@@ -58,10 +62,24 @@ const CONTINUATION_TTL_MS = 10 * 60 * 1000;
  * 实测反而把模型带进"先看看手里有什么、再决定读不读文件"的分叉：某次真机会话里落的是**只剩指针**
  * 那一档（`fields` / `writableFields` / `editableFields` 全被移出 stdout），模型于是先 grep 找
  * `writableFields`、再读 `requiredFields`、发现 `fields` 是完整对象后又按 17 个字段 id 批量 grep，
- * **从头到尾没读那个文件**。现在超线只有一条路：照抄命令读文件。
+ * **从头到尾没读那个文件**。于是改成"超线只回提示"。
  *
- * **返回体里不再有任何表单属性** —— 字段清单、必填、历史参考值、`contextId` / `continuation`
- * 全部只在 resultFile 里，所以提示必须把"不读就没法继续"说透。
+ * ★ 2026-10-13（P0）修正**过度裁剪**：真机会话里"只回提示"的代价是模型**必然**去读那份落盘文件
+ * （`Read(..., limit: 2691)`，79,799 字符 ≈ 20k tokens），而它其实只需要两样东西——"要填哪些字段
+ * （含各自的默认值）"和"下一步用哪个 `contextId`"。现在超线时**连同 `contextId` /
+ * `historyRequestData` 一起回**，`fields` 则在"挂上后仍不超线"时一并回（见 `compactFormOutput`
+ * 的 `always` / `ifFits`），提示也随之从"照抄读命令"改成"不必读、需要运行时/系统字段时才读"，
+ * 把那次 3.9 s 读取 + ~20k tokens 上下文整个省掉。
+ *
+ * 2026-10-14：`createForm` 的字段清单合并成唯一一份 `fields` 后，`fields` 自己成了"超线与否"的
+ * 主要变量 —— 于是它被归入 `ifFits`：挂得下就挂（模型免读文件），挂不下才在提示里点名要读。
+ *
+ * ★ 2026-10-14 晚（真机反证，改动 A+B）：**宿主截断不受这条 24,000 线约束**。真机会话里 24,417 B
+ * 的 `createForm` 输出被宿主**中段截掉 9,330 字符**（头尾保留、中间省略），丢的正是 `fields` 前半段；
+ * 而紧凑档判定的结论是"挂得下" ⇒ 提示说"不必读取"、模型却必须去读，**两笔成本都付了**。两处修正：
+ * ① 回挂键从 `{always, ifFits}` 改成**有序清单**（`FormOutputKeepEntry[]`），把 `fields` 提到
+ * `historyRequestData` 之前 —— 中段截断保留头部，先保"要填哪些字段"；② 提示语从断言改成**条件式**
+ * （"输出完整就不必读取；若被截断……读一次补齐"，见 `resultFileNotice`）。
  *
  * 落盘不可用时没有文件可指，只能保持全量输出（宁大不丢数据），只补一句说明。
  */
@@ -69,36 +87,154 @@ const CONTINUATION_TTL_MS = 10 * 60 * 1000;
 const READ_WHOLE_OUTPUT_HINT = '读取本输出请一次读完：不要用 head/tail 等管道截断'
     + '（截断会破坏 JSON，并导致重复执行同一条命令）。';
 /**
- * 超线时的**唯一**返回内容：落盘路径 + 一条可直接照抄的读文件命令（措辞由用户 2026-09-29 指定）。
+ * `createForm` 单次输出的**字符**安全线（2026-10-15 用户裁定）。
+ *
+ * 与 `STDOUT_SAFE_BYTES`（24,000 **字节**，`editLoad` / 查询类共用）是两个独立口径，不可互相套用：
+ * 本线按**字符**计，中文 1 字符 = 3 字节 ⇒ 同样一份表单输出按本线更容易触线。
+ * 用户给定的宿主侧限制实现（`terminal_tool.py` 的 `MAX_OUTPUT_LEN`）也按字符计，故取整 20,000。
+ *
+ * ★ 量的对象是**最终打出去的那份文本**（`finalStdoutChars`：信封 + 紧凑路径），不是美化 JSON
+ * —— 后者在 `fields` / `historyRequestData` / `systemFields` 走紧凑路径后能高估约 30%。
+ */
+const CREATE_FORM_STDOUT_SAFE_CHARS = 20_000;
+/**
+ * `durationMs` 进判线时用的**位数哨兵**（见 `FormOutputCharBudget.reserve`）。
+ *
+ * 该值只参与判线的宽度估算、**不会**被下发：真实耗时在压缩之后才求值，判线那一刻只能用位数把它先
+ * 占住。8 位 ≈ 27.8 小时，远超单条命令的合理上限 —— 哨兵比真值多几个字符时判线会略微高估，代价是
+ * 边界上的表单**提前**落盘；反过来低估才会让宿主按 `MAX_OUTPUT_LEN = 20000` 真截断，那才是要避免的。
+ */
+const DURATION_RESERVE_SENTINEL = 99_999_999;
+/**
+ * `createForm` 超线时的**唯一**回执（2026-10-15 用户裁定，措辞由用户逐字给定）。
+ *
+ * 超线就**不再回 JSON**：完整结果落盘，stdout 只留这一句。`contextId` / `fields` /
+ * `historyRequestData` 也随之**一律不回挂** —— 它们在落盘文件里都是完整的，模型读一次文件即可取到
+ * （含下一步 `createRequest` 要用的 `contextId`）。这与 `editLoad` 那一档（同为"只回提示"）形态一致。
+ */
+function createFormResultFileNotice(resultFile) {
+    return `当前表单内容较大，已临时写入文件 ${resultFile}，请直接读取 ${resultFile} 获取完整结果`;
+}
+/**
+ * 超线时的**提示行**（措辞由用户 2026-09-29 首定，2026-10-13 P0 改为"不必读"口径）。
+ *
+ * 用户 2026-09-29 的原始要求：提示里**直接给出可执行的读命令**（工具 + `file_path` + 精确 `limit`），
+ * 避免模型自己把 `limit` 给小了、于是分段读好几次 —— 这条保留。
+ *
+ * P0 起：`contextId` / `historyRequestData` 已随超线档一起返回，所以 **Read 不是必经步骤**，
+ * 只在需要运行时 / 系统字段这类细节时才用；首句先说清"不必读取"，否则模型仍会照抄去读（那正是要省的）。
  *
- * 用户明确要求：① 超线**只回提示**，不再回任何精简属性 —— 否则模型会先思考一段再决定读不读；
- * ② 提示里**直接给出可执行的读命令**（工具 + `file_path` + 精确 `limit`），避免模型自己把 `limit`
- * 给小了、于是分段读好几次；③ **除这两行外一个字都不要**（原话："其余内容都去掉"）。
+ * 2026-10-14：`fields`（字段清单 + 默认值）也可能被挂在超线档里（`ifFits` 口径）。**挂上才有资格说
+ * "不必读取"**——挂不上时提示语要反过来明确要模型去读，否则它会拿着一份没有字段清单的 stdout 硬拼
+ * `data`。`fieldsIncluded` 就是按"最终到底挂没挂上 `fields`"传进来的。
+ *
+ * ★ 2026-10-14 晚（改动 A）：上述"挂上就说不必读取"是**断言**，而它的隐含前提——"内联出去的
+ * ~24 KB 一定能被模型完整看到"——被真机会话证伪：宿主把 24,417 B 的输出**中段截掉 9,330 字符**，
+ * 挂在里面的 `fields` 前半段整段消失。于是 `fieldsIncluded` 为真时不再断言"不必读取"，改成**条件式**：
+ * 输出完整就不必读，**若被截断**（出现「已截断…字符」提示 / 字段清单不完整）则读一次补齐。
+ * 判据本身仍保留——它决定的是"该不该说可以省掉这次读取"，不是"输出一定完整"。
  *
  * `lines` 是落盘文件的总行数，正好是一次读完所需的 `limit`。文件读取工具不受宿主 stdout 那条
  * ~30 KB 内联线约束（实测 76 KB / 238 KB 都能一次读回）。
  */
-function resultFileNotice(resultFile, lines) {
-    return `表单内容较大，已写入临时文件（resultFile：${resultFile}），无需思考，直接运行下面的命令读取完整表单内容：`
-        + `\nRead(file_path: "${resultFile}", limit: ${lines})`;
+function resultFileNotice(resultFile, lines, fieldsIncluded = true) {
+    const head = `表单内容较大，完整表单已写入临时文件（resultFile：${resultFile}）。`;
+    const advice = fieldsIncluded
+        ? '**输出完整就不必读取**：字段清单（含 `initialValue`）与历史参考值都已随 stdout 下发，下一步 createRequest 用 contextId 即可；'
+            + '**若本输出被截断**（出现「已截断…字符」之类提示，或字段清单明显不完整），说明前部被省略的正是拼 `data` 需要的字段 —— 按下面命令读一次补齐（不要分段读）：'
+        : '**字段清单未随 stdout 下发**（它本身就超了内联线）——拼 `data` 前必须把它读一次（不要分段读）：';
+    return head + advice + `\nRead(file_path: "${resultFile}", limit: ${lines})`;
+}
+/**
+ * 量「这份 `data` 落进 stdout 后，宿主会看到多少字符」——**与最终输出同源的那一份文本**。
+ *
+ * 为什么不能沿用"美化 JSON 的 `.length`"：紧凑路径（`fields` / `historyRequestData` /
+ * `systemFields`，见 `stdout-compact.ts`）会把这几块的缩进空白整段压掉，实测 `createForm`
+ * 整份实测小 **约 30%**（`hugeLayout(120)` 桩 23,522 → 16,613 字符）。判线若还按美化量就会系统性
+ * 高估 —— 该内联的表单被判超线落盘。
+ *
+ * 信封形状必须与 `shortcuts/workflow/index.ts` 的 `successEnvelope` **同形**（`createForm` 不带
+ * `meta`，故此处没有该键）：测试用真的 `successEnvelope` + `stringifyForStdout` 复算 `outputChars`
+ * 把它锁住，`successEnvelope` 一改形状这条用例就会红。
+ */
+function finalStdoutChars(data, operation) {
+    const envelope = { schemaVersion: 1, ok: true, operation, data, warnings: [] };
+    return stdoutCharsOf(envelope, compactStdoutPaths(operation));
 }
-async function compactFormOutput(result, env, resultFileName) {
+/**
+ * 大表单输出裁剪：超安全线就落盘 + 只回指针。
+ *
+ * `keep` 是**回挂**给调用方的口子（2026-10-14 起；当晚从 `{always, ifFits}` 两桶改成**有序清单**）：
+ * - 不给 `ifFits`：无论多大都必须留在 stdout —— 它们是"不读那份文件也能继续干活"的全部依据；
+ * - 给 `ifFits: true`：**挂上后仍在安全线内才留**（如 `fields`）。真·巨型表单挂不回去，此时只能让
+ *   模型去读文件，提示语也随最终是否挂上 `fields` 改写（见 `resultFileNotice`）。
+ *
+ * ★ 顺序为什么是契约（2026-10-14 晚，真机反证）：宿主可能**中段截断**（头尾保留、中间省略），
+ * 所以"排在前面的键先保"。真机那次把 `fields` 排在 `historyRequestData` **之后**，截断正好吃掉
+ * `fields` 前半段 ⇒ 现在规定 `contextId` → `fields` → `historyRequestData` 的次序。
+ *
+ * 传 `charBudget` 则进**严格档**（`createForm` 专用，2026-10-15 用户裁定）：改用**字符**口径判线，
+ * 且超线时**只回那一句提示**、`keep` 整份失效 —— 与上面默认档「回挂干活必需键」的口径**正好相反**，
+ * 两者不要互相套用。`editLoad` 走默认档（字节口径 + 无 keep），行为不变。
+ */
+async function compactFormOutput(result, env, resultFileName, keep = [], charBudget) {
+    const entries = keep.filter((entry) => entry && entry.value !== undefined);
+    const entriesObject = (list) => {
+        const out = {};
+        for (const entry of list)
+            out[entry.key] = entry.value;
+        return out;
+    };
+    // ★ 严格档（`createForm`）：**字符**口径判线；超线时 stdout 只留那一句提示。
+    if (charBudget) {
+        // `chars` 是**原值**：`outputChars` 自述的就是"这份 `data` 有多大"，口径必须与落盘文件里那份
+        // 载荷严格一致（用例 `outputChars 必须等于「最终 stdout 文本」的字符数` 锁着这一条）。
+        const chars = finalStdoutChars(result, charBudget.operation);
+        // `measured` 只在阈值比较里用：`reserve` 里的键（`durationMs`）"结果里会有、判线时还没有值"，
+        // 按位数用哨兵把它占住（见 `FormOutputCharBudget.reserve`）——宁可高估提前落盘，不可低估被截断。
+        const measured = charBudget.reserve
+            ? finalStdoutChars({ ...result, ...charBudget.reserve }, charBudget.operation)
+            : chars;
+        // 未超线 ⇒ 原样返回完整结果（与默认档同形，`keep` 本就是 `result` 里已有的键）。
+        if (measured <= charBudget.safeChars)
+            return { ...result, ...entriesObject(entries) };
+        const payload = JSON.stringify(result, null, 2);
+        const resultFile = await writeStateFileBestEffort(resultFileName, payload, env.ctx);
+        if (!resultFile) {
+            // 落盘不可用 ⇒ 没有文件可指，只能保持全量输出（宁大不丢数据），与默认档同口径。
+            return {
+                ...result,
+                ...entriesObject(entries),
+                outputChars: chars,
+                largeOutputNotice: READ_WHOLE_OUTPUT_HINT,
+            };
+        }
+        // 只回那一句（`resultFile` 排最前，被截断也看得见）。
+        return withLeadingMeta({
+            resultFile,
+            persistedResult: true,
+            outputChars: chars,
+            largeOutputNotice: createFormResultFileNotice(resultFile),
+        }, {});
+    }
     const bytes = stdoutBytesOf(result);
     // 未超本地安全线 ⇒ 原样返回，不做任何裁剪、也不落盘。
     if (bytes <= STDOUT_SAFE_BYTES)
-        return result;
+        return { ...result, ...entriesObject(entries) };
     const payload = JSON.stringify(result, null, 2);
     const resultFile = await writeStateFileBestEffort(resultFileName, payload, env.ctx);
     if (!resultFile) {
-        return { ...result, outputBytes: bytes, largeOutputNotice: READ_WHOLE_OUTPUT_HINT };
+        return { ...result, ...entriesObject(entries), outputBytes: bytes, largeOutputNotice: READ_WHOLE_OUTPUT_HINT };
     }
+    const lines = payload.split('\n').length;
     // 只回提示：路径说明 + 读命令（`resultFile` 排最前，被截断也看得见）。
-    return withLeadingMeta({
-        resultFile,
-        persistedResult: true,
-        outputBytes: bytes,
-        largeOutputNotice: resultFileNotice(resultFile, payload.split('\n').length),
-    }, {});
+    const pointer = () => withLeadingMeta({ resultFile, persistedResult: true, outputBytes: bytes, largeOutputNotice: '' }, {});
+    const withOptional = { ...pointer(), ...entriesObject(entries) };
+    const final = entries.some((entry) => entry.ifFits) && stdoutBytesOf(withOptional) > STDOUT_SAFE_BYTES
+        ? { ...pointer(), ...entriesObject(entries.filter((entry) => !entry.ifFits)) }
+        : withOptional;
+    final.largeOutputNotice = resultFileNotice(resultFile, lines, 'fields' in final && Boolean(final.fields));
+    return final;
 }
 async function requestJson(env, method, path, query, body, options = {}) {
     const response = await env.host.workflowRequest({
@@ -583,15 +719,6 @@ function slimFieldInfo(field) {
         slim.optionsTruncated = true;
     return slim;
 }
-function requiredFieldsWithSystem(formRequired, runtime, sysPermissions) {
-    const ids = formRequired.map((f) => String(f.id ?? ''));
-    for (const sysKey of Object.keys(SYSTEM_FIELD_KEYS)) {
-        const perm = sysPermissions[sysKey] || {};
-        if (perm.isview && perm.ismandatory)
-            ids.push(sysKey);
-    }
-    return ids;
-}
 // ---------------------------------------------------------------------------
 // 附件上传限制解析
 // ---------------------------------------------------------------------------
@@ -858,6 +985,320 @@ function buildFileUploadParams(runtime, frame, fieldId, isCreate, secretLevelId,
         params.maxNum = maxNum;
     return params;
 }
+/**
+ * 布局里**隐藏行**上的字段（2026-10-14 用户口径，V12.1.112）。
+ *
+ * 用户在表单上看到的是一张 Excel 表：`config.workbook` 每个「节点」都有自己的行列网格——
+ * `Sheet1` 是**页面根网格**，其余键是**容器组件自己的网格**（如明细表 `DetailTable` 的内部网格）。
+ * `sheet.rows[i].visible === false` ⇒ **该整行内容在前台一律不可见**。
+ *
+ * 为什么必须补这条：`流程类型` / `打印状态` 在 `fields[]` 与 `viewRelateConfig` 里跟普通业务
+ * Select（如 `报销方式`）**逐键同形**——`readOnly`/`disableEdit` 都是 false、`display` 也是 true、
+ * 连默认值都有，载荷里**没有任何"这是隐藏字段"的标记**。它们唯一的不同就是**落在隐藏行上**
+ * （真机 总部费用报销：两者都在 `Sheet1.rows` 第 76 行，该行 `visible:false`，整块 74~83 行全隐藏）。
+ *
+ * 判定必须**沿容器链往上走**：组件的 `config.excel.row` 是**相对其父容器**的坐标
+ * （`excel.parent === 'ROOT'` 才是页面根网格），父容器本身还可能是一个组件——真机
+ * `单据状态` / `收单日期` / `到达出纳日期` / `分部` 这些字段就挂在 `MultiContent` 组合控件里，
+ * 是组合控件本体（第 76 行）被藏了 ⇒ 它内部所有字段用户同样看不到（用户原话："该行的所有内容
+ * 在表单上都是隐藏的"）。任一层落在隐藏行上即判隐藏。
+ *
+ * 查不到对应网格时（老布局 / 节点缺失 / `workbook` 整个没有）**不判隐藏**——fail-open，
+ * 与 `compsFieldIds` 为空时不筛同一降级口径：宁多返字段，不可误删用户真能看到的字段。
+ */
+function collectHiddenRowFieldIds(page0, comps) {
+    const hiddenRowFieldIds = new Set();
+    const workbook = page0?.config?.workbook;
+    if (!workbook || typeof workbook !== 'object')
+        return hiddenRowFieldIds;
+    const rootSheet = workbook.Sheet1;
+    // nodeId → 组件：组件的 `excel.parent` 指向父容器的 nodeId，靠它才能找回父容器自己的网格。
+    const compByNodeId = new Map();
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const nodeId = String(comp.config?.excel?.nodeId ?? '').trim();
+        if (nodeId)
+            compByNodeId.set(nodeId, comp);
+    }
+    const rowHidden = (sheet, row) => {
+        const rows = sheet && Array.isArray(sheet.rows) ? sheet.rows : [];
+        const index = Number(row);
+        if (!Number.isInteger(index) || index < 0 || index >= rows.length)
+            return false;
+        const entry = rows[index];
+        return Boolean(entry) && typeof entry === 'object' && entry.visible === false;
+    };
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const fieldId = String(comp.config?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        let cursor = comp;
+        while (cursor) {
+            const excel = cursor.config?.excel;
+            if (!excel || typeof excel !== 'object')
+                break;
+            const parentId = String(excel.parent ?? '').trim();
+            if (!parentId || parentId === 'ROOT') {
+                if (rowHidden(rootSheet, excel.row))
+                    hiddenRowFieldIds.add(fieldId);
+                break;
+            }
+            const owner = compByNodeId.get(parentId);
+            const sheet = owner ? workbook[String(owner.id ?? '')] : null;
+            if (sheet && rowHidden(sheet, excel.row)) {
+                hiddenRowFieldIds.add(fieldId);
+                break;
+            }
+            cursor = owner;
+        }
+    }
+    return hiddenRowFieldIds;
+}
+/**
+ * 明细表**隐藏列**上的字段（2026-10-14 用户口径，V12.1.116）。
+ *
+ * 明细表在 `comps[]` 里是 `type === 'DetailTable'` 的组件：
+ * `comp.id` 是它在 `pageLayouts[0].config.workbook` 里的**网格 key**（用户口径里的「标签页 key」），
+ * `comp.config.subFormId`（真机同 `comp.refBusinessId`）是该明细表自己的 id。
+ * 该网格 `columns[n].visible === false` ⇒ **第 n 列整列在表单上不显示**，列上的字段用户在前台
+ * 看不到；载荷里与隐藏行一样**没有任何"隐藏"标记**（只有布局知道）。真机实例（总部费用报销）：
+ * 一张 34 列的明细表有 22 列 `visible:false`，涉及 27 个字段。
+ *
+ * 列 → 字段的寻址与隐藏行同一套：字段组件的 `config.excel.parent` 指向**明细表组件的
+ * `excel.nodeId`**、`config.excel.col` 是**列号**（0 起，与 `columns` 下标同口径）。沿容器链往上走，
+ * 任一层落在明细网格的隐藏列上即判隐藏（明细表内的组合控件落在隐藏列时，其内部字段同样看不到）。
+ *
+ * **只认明细表网格**：页面根网格（`Sheet1`）的列隐藏不在本口径内（真机无此态）。
+ * 查不到明细网格 / `columns` 缺失时**不判隐藏**——fail-open，与隐藏行同一降级口径。
+ */
+function collectHiddenDetailColumnFieldIds(page0, comps) {
+    const hiddenColFieldIds = new Set();
+    const workbook = page0?.config?.workbook;
+    if (!workbook || typeof workbook !== 'object')
+        return hiddenColFieldIds;
+    const sheets = workbook;
+    // nodeId → 组件（组件的 `excel.parent` 指向父容器的 nodeId）；同时挑出明细表的网格 key。
+    const compByNodeId = new Map();
+    const detailSheetKeys = new Set();
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const nodeId = String(comp.config?.excel?.nodeId ?? '').trim();
+        if (nodeId)
+            compByNodeId.set(nodeId, comp);
+        const type = String(comp.type ?? comp.config?.type ?? '').trim().toLowerCase();
+        if (type !== 'detailtable')
+            continue;
+        const sheetKey = String(comp.id ?? '').trim();
+        if (sheetKey && sheets[sheetKey] && typeof sheets[sheetKey] === 'object')
+            detailSheetKeys.add(sheetKey);
+    }
+    if (!detailSheetKeys.size)
+        return hiddenColFieldIds;
+    const colHidden = (sheet, col) => {
+        const columns = sheet && Array.isArray(sheet.columns) ? sheet.columns : [];
+        const index = Number(col);
+        if (!Number.isInteger(index) || index < 0 || index >= columns.length)
+            return false;
+        const entry = columns[index];
+        return Boolean(entry) && typeof entry === 'object' && entry.visible === false;
+    };
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const fieldId = String(comp.config?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        let cursor = comp;
+        while (cursor) {
+            const excel = cursor.config?.excel;
+            if (!excel || typeof excel !== 'object')
+                break;
+            const parentId = String(excel.parent ?? '').trim();
+            if (!parentId || parentId === 'ROOT')
+                break; // 页面根网格不参与本口径
+            const owner = compByNodeId.get(parentId);
+            if (!owner)
+                break;
+            const ownerId = String(owner.id ?? '').trim();
+            if (detailSheetKeys.has(ownerId)) {
+                if (colHidden(sheets[ownerId], excel.col))
+                    hiddenColFieldIds.add(fieldId);
+                break;
+            }
+            cursor = owner;
+        }
+    }
+    return hiddenColFieldIds;
+}
+/**
+ * 多内容单元格（`MultiContent`）内部**被隐藏的单元格**上的字段（2026-10-14 用户口径，V12.1.117）。
+ *
+ * `comps[]` 里 `type === 'MultiContent'` 是「多内容单元格」组合控件：它把若干子字段摆在自己
+ * **内嵌的**单元格网格里——`config.excel.multiCells`，形如 `[row][col]` 的二维数组（空格子为 `null`），
+ * 每个单元格形如 `{ nodeId, value, style, tag }`。`cell.nodeId` 与子字段组件的
+ * `config.excel.nodeId` 一一对应（真机 41/41 命中，且 `multiCells` 的行列下标与子字段
+ * `excel.row` / `excel.col` 也 41/41 一致）。单元格 `cell.tag.attrs.hide === true`
+ * ⇒ **该单元格里的字段内容在前台不可见**；载荷里与隐藏行 / 隐藏列一样**没有任何"隐藏"标记**，
+ * 只有布局知道。真机实例（总部费用报销）：`部门;部门ID` 这个多内容单元格里第二个格子
+ * （`部门ID`，`fieldId 100003720000001374`）就是 `tag.attrs.hide === true`，而同格的
+ * `部门`（`100003720000000074`）照常可见。
+ *
+ * **`MultiContent` 不在 `config.workbook` 里**（它没有自己的 sheet），所以隐藏行 / 隐藏列的
+ * 网格口径天然覆盖不到它——必须单独读内嵌的 `multiCells`。
+ *
+ * 寻址与隐藏行 / 隐藏列同一套：沿容器链往上走，任一层的组件若是 `MultiContent` 且其 `multiCells` 里
+ * 有指向当前 cursor 的 `nodeId` 且该单元格 `hide === true` 即判隐藏（多内容里再嵌组合控件时，
+ * 其内部字段同样看不到）。`multiCells` 缺失 / 结构异常时**不判隐藏**——fail-open，同一降级口径。
+ */
+function collectHiddenMultiContentFieldIds(comps) {
+    const hiddenFieldIds = new Set();
+    const list = toArray(comps);
+    // nodeId → 组件：组件的 `excel.parent` 指向父容器的 nodeId，靠它才能沿容器链往上走。
+    const compByNodeId = new Map();
+    // **被隐藏的单元格**所对应的子组件 nodeId 集合（`multiCells` 里 `tag.attrs.hide === true` 的那批）。
+    const hiddenCellNodeIds = new Set();
+    for (const comp of list) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const nodeId = String(comp.config?.excel?.nodeId ?? '').trim();
+        if (nodeId)
+            compByNodeId.set(nodeId, comp);
+    }
+    for (const comp of list) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const type = String(comp.type ?? comp.config?.type ?? '').trim().toLowerCase();
+        if (type !== 'multicontent')
+            continue;
+        const cells = comp.config?.excel?.multiCells;
+        if (!Array.isArray(cells))
+            continue;
+        for (const row of cells) {
+            // `multiCells` 是 `[row][col]` 二维数组，空格子是 `null`。
+            if (!Array.isArray(row))
+                continue;
+            for (const cell of row) {
+                if (!cell || typeof cell !== 'object')
+                    continue;
+                const attrs = cell.tag?.attrs;
+                if (!attrs || typeof attrs !== 'object' || attrs.hide !== true)
+                    continue;
+                const cellNodeId = String(cell.nodeId ?? '').trim();
+                if (cellNodeId)
+                    hiddenCellNodeIds.add(cellNodeId);
+            }
+        }
+    }
+    if (!hiddenCellNodeIds.size)
+        return hiddenFieldIds;
+    for (const comp of list) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const fieldId = String(comp.config?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        let cursor = comp;
+        while (cursor) {
+            const excel = cursor.config?.excel;
+            if (!excel || typeof excel !== 'object')
+                break;
+            const nodeId = String(excel.nodeId ?? '').trim();
+            if (nodeId && hiddenCellNodeIds.has(nodeId)) {
+                hiddenFieldIds.add(fieldId);
+                break;
+            }
+            const parentId = String(excel.parent ?? '').trim();
+            if (!parentId || parentId === 'ROOT')
+                break;
+            cursor = compByNodeId.get(parentId) ?? null;
+        }
+    }
+    return hiddenFieldIds;
+}
+/**
+ * 页面根网格（Sheet1）上**被隐藏的单元格**里的字段（2026-10-20 修复）。
+ *
+ * `pageLayouts[0].config.workbook.Sheet1.cells[]` 里 `cell.tag.attrs.hide === true`
+ * ⇒ 该单元格（`col:row`）在表单上不显示，格子里的字段用户看不到。
+ *
+ * 寻址必须**沿容器链往上走**（与隐藏行 / 隐藏列 / 多内容格同一套）：组件的 `config.excel.col`/`row`
+ * 是**相对其父容器**的坐标，只有 `excel.parent === 'ROOT'` 那一层才是 Sheet1 的行列号。
+ * 真机反例（总部费用报销，「报销人直接上级」`fieldId 100003720000076596`）：字段自身的坐标是
+ * `col:0,row:0`（相对它所在的 `MultiContent` 容器），真正被藏起来的是 Sheet1 上 `col:3,row:4`
+ * 那个格子里的**容器本体**——只比字段自己的坐标就永远不可能命中，值于是漏进「已填内容」。
+ *
+ * 之前这里的实现只拿 comp 自己的 `excel.col:row` 与 Sheet1 的隐藏格直接比对，组合控件（尤其是
+ * `MultiContent`）内部的字段一概漏判；改成沿链上溯后，容器被藏 ⇒ 它内部所有字段一并判隐藏。
+ *
+ * 查不到 `cells` / 没有隐藏格时**不判隐藏**——fail-open，与其它隐藏口径同一降级原则。
+ */
+function collectHiddenSheetCellFieldIds(page0, comps) {
+    const hiddenFieldIds = new Set();
+    const sheet1 = page0?.config?.workbook?.Sheet1;
+    const cells = sheet1 && Array.isArray(sheet1.cells) ? sheet1.cells : [];
+    if (!cells.length)
+        return hiddenFieldIds;
+    /** `col:row`（两边同口径归一成数字，避免 `"3"` 与 `3` 对不上）；坐标不可解析时返回 null。 */
+    const posOf = (col, row) => {
+        const c = Number(col);
+        const r = Number(row);
+        if (!Number.isFinite(c) || !Number.isFinite(r))
+            return null;
+        return `${c}:${r}`;
+    };
+    const hidePositions = new Set();
+    for (const cell of cells) {
+        if (!cell || typeof cell !== 'object')
+            continue;
+        const attrs = cell.tag?.attrs;
+        if (!attrs || typeof attrs !== 'object' || !attrs.hide)
+            continue;
+        const pos = posOf(cell.col, cell.row);
+        if (pos)
+            hidePositions.add(pos);
+    }
+    if (!hidePositions.size)
+        return hiddenFieldIds;
+    // nodeId → 组件：组件的 `excel.parent` 指向父容器的 nodeId，靠它才能找回父容器自己的坐标。
+    const compByNodeId = new Map();
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const nodeId = String(comp.config?.excel?.nodeId ?? '').trim();
+        if (nodeId)
+            compByNodeId.set(nodeId, comp);
+    }
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const fieldId = String(comp.config?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        let cursor = comp;
+        while (cursor) {
+            const excel = cursor.config?.excel;
+            if (!excel || typeof excel !== 'object')
+                break;
+            const parentId = String(excel.parent ?? '').trim();
+            if (!parentId || parentId === 'ROOT') {
+                // 到根网格这一层才是 Sheet1 的真实行列号（容器内的坐标是相对的，比不得）。
+                const pos = posOf(excel.col, excel.row);
+                if (pos && hidePositions.has(pos))
+                    hiddenFieldIds.add(fieldId);
+                break;
+            }
+            const owner = compByNodeId.get(parentId);
+            if (!owner)
+                break;
+            cursor = owner;
+        }
+    }
+    return hiddenFieldIds;
+}
 function parseLayoutMeta(layoutData) {
     const hiddenCellIds = new Set();
     const compsFieldIds = new Set();
@@ -867,44 +1308,6 @@ function parseLayoutMeta(layoutData) {
     if (Array.isArray(pageLayouts) && pageLayouts.length)
         page0 = pageLayouts[0];
     if (page0 && typeof page0 === 'object') {
-        const wb = page0.config && page0.config.workbook ? page0.config.workbook : {};
-        const sheet1 = wb.Sheet1;
-        const cells = sheet1 ? sheet1.cells : null;
-        const hidePositions = new Set();
-        if (Array.isArray(cells)) {
-            for (const cell of cells) {
-                if (!cell || typeof cell !== 'object')
-                    continue;
-                const attrs = cell.tag && cell.tag.attrs ? cell.tag.attrs : {};
-                if (attrs.hide) {
-                    try {
-                        hidePositions.add(`${cell.col}:${cell.row}`);
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }
-        }
-        if (hidePositions.size) {
-            for (const comp of page0.comps || []) {
-                if (!comp || typeof comp !== 'object')
-                    continue;
-                const cfg = comp.config || {};
-                const fid = String(cfg.fieldId ?? '').trim();
-                if (!fid)
-                    continue;
-                const excel = cfg.excel || {};
-                try {
-                    const pos = `${excel.col}:${excel.row}`;
-                    if (hidePositions.has(pos))
-                        hiddenCellIds.add(fid);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-        }
         for (const comp of page0.comps || []) {
             if (!comp || typeof comp !== 'object')
                 continue;
@@ -918,6 +1321,18 @@ function parseLayoutMeta(layoutData) {
                     layoutSubformIds.add(sid);
             }
         }
+        // 行隐藏 / 单元格隐藏 / 明细表隐藏列 / 多内容单元格隐藏**同义**（都是"用户在表单上看不到"），
+        // 并成一份 `hiddenCellIds`：下游 `visibleFields`/`initialValue`/`missingRequiredFields`/「已填内容」
+        // /联动提示全部只认这一份，且随句柄以 `hiddenCellFieldIds` 传给 `createRequest`，两边口径天然一致。
+        // 单元格隐藏**必须沿容器链上溯**（2026-10-20 修复）：容器的 `excel` 坐标才是 Sheet1 上的位置。
+        for (const fid of collectHiddenSheetCellFieldIds(page0, page0.comps))
+            hiddenCellIds.add(fid);
+        for (const fid of collectHiddenRowFieldIds(page0, page0.comps))
+            hiddenCellIds.add(fid);
+        for (const fid of collectHiddenDetailColumnFieldIds(page0, page0.comps))
+            hiddenCellIds.add(fid);
+        for (const fid of collectHiddenMultiContentFieldIds(page0.comps))
+            hiddenCellIds.add(fid);
     }
     return { hiddenCellIds, compsFieldIds, layoutSubformIds };
 }
@@ -940,7 +1355,8 @@ function applyViewRelateHidden(layoutSubformIds, viewRelateConfig) {
  * `viewRelateConfig` 长度为 0"并非服务端没配置，而是 `getFormLayout` 请求多带了顶层 `permissionId`
  * （未启用节点权限的表单会因此拿不到字段级属性；见 `buildLayoutRequest`）。该请求口径修正后，
  * 本告警只在服务端**确实**不下发字段属性时才出现（如启用节点权限的表单）。
- * 真正未下发时：`requiredFields` 只剩系统字段、`subFormRequired` 恒为 `{}`，**不代表表单没有必填项**。
+ * 真正未下发时：服务端没有字段级的 required / disableEdit / display 配置，`fields` 里的只读 / 禁止编辑
+ * 判定与「标记未下发」都因此失真，**不代表表单没有必填项**。
  *
  * V12.1.27 纠正（此前措辞有硬伤）：原文案把 `missingFields` 也写成"为空不代表没有必填/无法据此校验业务必填"，
  * 与事实相反——本租户的业务必填多为**条件必填**（`viewLinkages` 的 `required` 规则），
@@ -950,13 +1366,16 @@ function applyViewRelateHidden(layoutSubformIds, viewRelateConfig) {
  *
  * 2026-09-23：`createForm` 不再下发联动规则（原 `conditionalRequired`），必填判断一律以 `missingFields` 为准。
  *
- * 返回 null 表示静态必填信息可用，无需告警。
+ * 2026-10-14：`createForm` 不再下发任何必填清单（`requiredFields` / `subFormRequired` / `fillPlan` 全撤），
+ * 本告警的措辞随之改成"静态权限信息没拿到"，不再点名那三个已不存在的键。
+ *
+ * 返回 null 表示静态权限信息可用，无需告警。
  */
 function requiredInfoWarningText(context) {
     const ctx = context || {};
     const vrc = Array.isArray(ctx.viewRelateConfig) ? ctx.viewRelateConfig : [];
     if (vrc.length)
-        return null; // OA 下发了字段级权限配置 → 静态必填信息可信
+        return null; // OA 下发了字段级权限配置 → 字段的只读 / 可见判定可信
     const fields = Array.isArray(ctx.fields) ? ctx.fields : [];
     const business = fields.filter((f) => f && f.id
         && !String(f.id).startsWith('REQUEST_') && !String(f.id).startsWith('SECLEVEL')
@@ -967,27 +1386,39 @@ function requiredInfoWarningText(context) {
     // 有任何字段带必填标记 → 至少拿到了部分真实信息，不必告警
     if (business.some((f) => f.required))
         return null;
-    return 'OA 未下发该表单的**静态**必填标记，本次 requiredFields / subFormRequired 只含系统字段（流程标题等），'
+    return 'OA 未下发该表单的**静态**字段权限配置：本次 `fields` 里的只读 / 禁止编辑判定可能偏保守，'
         + '但这**不代表该表单没有业务必填项**——业务必填多为「条件必填」，只有按实际所填数据才判定得出。'
-        + 'missingFields 由 createRequest 按实际所填数据实时计算、**可信**：照常发起，'
-        + '返回 NEEDS_INPUT 时把 missingFields 一次性向用户问齐。'
+        + '必填一律以 createRequest 返回的 `missingFields` 为准（按实际所填数据实时计算、**可信**）：'
+        + '照常发起，返回 NEEDS_INPUT 时把 missingFields 一次性向用户问齐。'
         + '不要对用户说"系统不会校验必填项"。';
 }
 // ---------------------------------------------------------------------------
 // 发起侧工作流解析（原 createList 的职责；候选池 = 当前用户「可发起的工作流」）
 // ---------------------------------------------------------------------------
 /**
- * 把一个「纯名称」切成多个匹配关键词（2026-09-23 用户裁定）。
+ * 名称关键词的**填充词**（按长词优先依次脱壳）。
+ *
+ * 用户裁定：「去掉一些词：工作流、流程」（2026-09-23）；「现在要**额外去掉申请**关键字」
+ * （2026-10-21）。顺序有讲究：`工作流程` 必须排在 `工作流` / `流程` 之前
+ * （`工作流` 与 `流程` 在 `流` 处重叠，先剥短的会漏判）。
+ */
+const CREATE_KEYWORD_FILLERS = ['工作流程', '工作流', '流程', '申请'];
+/**
+ * 把一个「纯名称」切成多个名称关键词（2026-09-23 用户裁定 + 2026-10-21 追加净词）。
  *
  * 单个格内可用逗号分隔多个关键词（中英文逗号都认），也可用数组多元素表达；命中结果做**并集**，
- * 目的是**提高候选召回** —— 用户首次要发起某个流程时，多给几个说法更容易命中他真正要发起的那个，
- * 从而少让用户回来补全名称。
- *
- * 去词规则（用户裁定，逐字）：「**去掉一些词：工作流、流程**」。落到实现上是——
- * **只丢弃"整格就是填充词"的关键词**（`流程` / `工作流` / `工作流程`），其余**原样保留**：
- * - `"报销,报销流程,流程"` → 关键词 = `报销`、`报销流程`（**两个**，`流程` 被丢掉）；
- * - `报销流程` **不在词内剥离** —— 它是有效关键词（剥成 `报销` 会让"多关键词"退化成单关键词）。
- * 匹配不到的关键词在并集里自然贡献为空，无害，所以不必额外清理。
+ * 目的是**提高候选召回** —— 用户首次要发起某个流程时，多给几个说法更容易命中他真正要发起的那个。
+ *
+ * 每个关键词带**两副面孔**（2026-10-21 用户裁定）：
+ * - `raw` = 原样（`请假流程`、`请假申请`）；
+ * - `core` = 去掉填充词后的净词（`请假流程` → `请假`、`请假申请` → `请假`、`总部请假` → `总部请假`）。
+ *
+ * 两者**都参与本地模糊过滤**（候选取并集），于是「请假申请」既按它自己、也按「请假」去找，
+ * 能命中「请假申请单」这类名字；净词与原词相同的词天然只算一次。
+ *
+ * **只丢弃"整格全是填充词"的关键词**（`流程` / `工作流` / `申请` …）：它们不代表任何业务含义，
+ * 留着会命中一大批无关流程。`报销申请` 这类**含填充词但本身有效**的词不会被丢 ——
+ * 它的净词 `报销` 才是干活的那个。
  */
 function splitCreateKeywords(raw) {
     const out = [];
@@ -996,15 +1427,18 @@ function splitCreateKeywords(raw) {
         const token = piece.trim();
         if (!token)
             continue;
-        // 填充词按**长词优先**脱壳：`工作流程` → 空（`工作流`+`流程` 在 `流` 处重叠，顺序错会漏判）
-        const residue = token.split('工作流程').join('').split('工作流').join('').split('流程').join('');
-        if (!residue.trim())
+        let core = token;
+        for (const filler of CREATE_KEYWORD_FILLERS)
+            core = core.split(filler).join('');
+        core = core.trim();
+        // 整格都是填充词 ⇒ 丢弃（留着会让 `流程` 命中「请假流程」「合同流程」等一大批）
+        if (!core)
             continue;
         const key = token.toLowerCase();
         if (seen.has(key))
             continue;
         seen.add(key);
-        out.push(token);
+        out.push({ raw: token, core });
     }
     return out;
 }
@@ -1018,10 +1452,17 @@ function splitCreateKeywords(raw) {
  * - **0 命中 → 澄清**：不能把「没听懂你的条件」伪装成「没有这条流程」，否则模型会如实转述成
  *   "没有该工作流"，用户拿不到可操作的信息；
  * - 1 命中 → 直接用；
- * - 多命中但候选中**恰有一个与所写名称完全一致** → 直接用，不为"要不要多打几个字"再问一次；
- * - 多命中且没有完全一致的 → 澄清并列出候选（`display` 即 `名称(ID)`，用户选定后原样回传）。
+ * - 多命中时，**全名一致必须唯一**才直接用（2026-10-21 用户二次裁定，撤销同日"按词序先到先得"）：
+ *   连"净词 + 原词"一起算，若与候选全名一致的说法只指向**同一个**候选 ⇒ 用它；若指向**多个不同**
+ *   候选（如 `费用报销,报销流程审批` 恰好各自对上一条）⇒ 这是用户给的条件本身有歧义，仍回来澄清；
+ * - 多命中且没有任何全名一致的 → 澄清并列出候选（`display` 即 `名称(ID)`，用户选定后原样回传）。
+ *   这一档在澄清**之前**先做一次消歧（2026-10-20 用户裁定）：把候选拿去查「我发起的」工作流树，
+ *   用户近一年只发起过其中**一个**就直接用它（`from:'mineRecentUnique'`）；否则/失败则照旧澄清。
+ *   **只有这一档会消歧**：0 命中、以及"只给了填充词"那两档都不查（前者本就没候选可比，
+ *   后者在发任何远端请求前就澄清了）。
  *
- * 名称格支持**多关键词**（`"报销,报销流程"`，见 `splitCreateKeywords`）：各关键词命中做并集去重后，
+ * 名称格支持**多关键词**（`"报销,报销流程"`，见 `splitCreateKeywords`）：每个关键词同时贡献
+ * **净词**与**原词**（`请假申请` → `请假` + `请假申请`），两组词各自命中后**并集去重**，
  * 再走上面同一套判据。**只发一次** `getNewFlowListData` 而不是每个关键词并行各发一次 —— 该接口
  * 请求体固定为 `{wfpBelongTypeCode, loadOfsFlow, clientCtrl}`、**没有任何关键词入参**（V11.3 Python
  * 基线 `e10_workflow_create.py:395-436` 同样是取全量后本地过滤；真机单笔 ≈1,649 ms / 228,929 B），
@@ -1044,8 +1485,17 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
     // 一个关键词都没解析出来（如只传了 `流程`）时**连可发起列表都不去拉**
     // （该接口真机单笔 ≈1,649 ms / 228,929 B），与"完全不传 workflow"同一口径。
     const explicitIds = new Set();
-    const nameTerms = [];
-    const keywordSeen = new Set();
+    /** 参与**本地模糊过滤**的词：每个关键词先净词、再原词（同一词只留一个）。 */
+    const filterTerms = [];
+    /**
+     * 参与**全名精确匹配**的词集合：每个关键词先净词、再原词（如 `请假申请` → `请假` + `请假申请`）。
+     *
+     * 只做集合比对、**不看先后次序**（2026-10-21 二次裁定：全名一致必须唯一才直接用，不允许按词序
+     * 先到先得）。
+     */
+    const exactTerms = [];
+    const filterSeen = new Set();
+    const exactSeen = new Set();
     for (const term of rawTerms) {
         const parsed = parseNameWithId(term);
         // 纯数字同样按 ID 处理（`parseNameWithId` 只认 "名称(数字)" 形态）
@@ -1055,14 +1505,29 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
             continue;
         }
         for (const keyword of splitCreateKeywords(parsed.name)) {
-            const key = keyword.toLowerCase();
-            if (keywordSeen.has(key))
-                continue;
-            keywordSeen.add(key);
-            nameTerms.push(keyword);
+            const coreKey = keyword.core.toLowerCase();
+            const rawKey = keyword.raw.toLowerCase();
+            // 模糊过滤：**单字净词不参与**（`申请单` 剥成 `单` 会把整张清单拉进来）；
+            // 原词永远参与，所以"只说得出一个怪名字"时召回不受影响。
+            if (keyword.core.length >= 2 && !filterSeen.has(coreKey)) {
+                filterSeen.add(coreKey);
+                filterTerms.push(keyword.core);
+            }
+            if (!filterSeen.has(rawKey)) {
+                filterSeen.add(rawKey);
+                filterTerms.push(keyword.raw);
+            }
+            if (!exactSeen.has(coreKey)) {
+                exactSeen.add(coreKey);
+                exactTerms.push(keyword.core);
+            }
+            if (!exactSeen.has(rawKey)) {
+                exactSeen.add(rawKey);
+                exactTerms.push(keyword.raw);
+            }
         }
     }
-    if (!explicitIds.size && !nameTerms.length) {
+    if (!explicitIds.size && !filterTerms.length) {
         throw workflowClarificationError('workflow', queryText, '要发起哪个流程？请提供该流程的完整名称（或其它可用于检索的关键词）后再继续。');
     }
     const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, {
@@ -1083,7 +1548,7 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
         }
     }
     // 名称关键词：逐个取命中，**并集去重**（多给几个说法只扩大候选面，不改变下面的命中判据）
-    for (const keyword of nameTerms) {
+    for (const keyword of filterTerms) {
         for (const item of simplifyWorkflows(data, keyword)) {
             if (seen.has(String(item.id)))
                 continue;
@@ -1098,13 +1563,30 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
         return { id, name: String(only.workflowname ?? ''), source: explicitIds.has(id) ? 'workflowId' : 'single' };
     }
     if (picked.length > 1) {
-        const wanted = new Set(nameTerms.map((t) => t.trim().toLowerCase()).filter(Boolean));
+        // ★ 2026-10-21 用户二次裁定：**退回「全名命中必须唯一」**——同日早先那版"按词序循环、第一个
+        // 全名一致的就用"已撤销。理由：多个说法各自全名命中**不同**候选时，用户给的条件本身就有歧义
+        // （两条互相竞争的精确证据），按词序替用户先到先得等于擅自替他裁决，宁可回来问一句。
+        //
+        // 仍算"唯一"、可直接用的两档：
+        // - 只有一个候选与某个说法全名一致，其余说法只是陪跑（命中的是别的、或没命中）；
+        // - 多个说法全名命中的是**同一个**候选（去重后仍是一条）。
+        // "说法"包含每个关键词的**净词**与**原词**（见 `exactTerms`），两者都参与比对。
+        //
+        // 某个说法命中**多条同名候选**（不同 id、名字一字不差）同样算不唯一 ⇒ 一并澄清。
+        const wanted = new Set(exactTerms.map((t) => t.trim().toLowerCase()).filter(Boolean));
         const exact = picked.filter((item) => wanted.has(String(item.workflowname ?? '').trim().toLowerCase()));
-        // 多命中时有唯一全名精确匹配 → 直接选中（与查询侧 exact_candidates 优选同一判据）
         if (exact.length === 1) {
             return { id: String(exact[0].id), name: String(exact[0].workflowname ?? ''), source: 'exactName' };
         }
+        // 澄清候选：能对上的那几条优先（比全量 picked 精确），一条都对不上才退回全量。
         const list = exact.length ? exact : picked;
+        // ★ 2026-10-20 用户裁定：澄清前先按「用户近一年实际发起过哪些」消歧。
+        // 用户只发起过其中某一个 ⇒ 直接用，不再问一遍（`from:mineRecentUnique` 标明这是推断的，
+        // 不是用户明说的）。查不到 / 不唯一 / 请求失败 ⇒ 一律回落下面原样的多候选澄清。
+        const inferred = await pickUniqueMineWorkflow(list.map((item) => ({ id: String(item.id), name: String(item.workflowname ?? '') })), env);
+        if (inferred) {
+            return { id: inferred.id, name: inferred.name, source: 'single', from: 'mineRecentUnique' };
+        }
         // `clarificationQuestion` 是**用户口径**：它会被 `note` 要求「原样交给用户确认」，因此
         // 只能写"发生了什么 + 要用户做什么"。**禁止**把本机判定依据（如"其中没有与所写名称完全
         // 一致的"）写进这句——那属于 CLI 内部实现，外传会让用户在确认卡片上看到与己无关的判据
@@ -1124,9 +1606,9 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
  *
  * 背景（2026-09-23 实测 + 用户裁定）：`POST …memoryPrompt` 带 `workflowId` 时返回的是**全集** ——
  * `--- user.md ---` / `--- memory.md ---`（全局画像 + 全局别名映射）+ `--- memory_<workflowId>.md ---`
- * （该工作流维度）。于是 `launchPreferences` 与入口处读过的无参 `workflow.memoryPrompt`（纯全局）
+ * （该工作流维度）。于是这条命令取回的记忆与入口处读过的无参 `workflow.memoryPrompt`（纯全局）
  * **内容重叠**：真机实测同一租户 `promptText` 2,467 字符 = 全局 543 + 工作流维度 1,924，
- * 同一段全局记忆会在上下文里出现两次。而 `launchPreferences` 的语义是「**该工作流的**发起偏好」，
+ * 同一段全局记忆会在上下文里出现两次。而这里要的是「**该工作流的**发起偏好」，
  * 全局那份已由入口读取覆盖，不应重复下发。
  *
  * 故只保留标记 `--- memory_<workflowId>.md ---` 及其**之后**的内容：
@@ -1149,16 +1631,17 @@ function extractWorkflowMemorySection(promptText, workflowId) {
     return text.slice(at).trim();
 }
 /**
- * 顺带取回用户在这条工作流上的发起偏好（`buildAgentMemoryPrompt`，带 `workflowId`）。
+ * 取回用户在这条工作流上的记忆（`buildAgentMemoryPrompt`，带 `workflowId`）。
  *
- * `promptText` **只含该工作流维度的记忆**（全局画像/全局别名由入口的无参 `workflow.memoryPrompt`
- * 覆盖，这里经 `extractWorkflowMemorySection` 裁掉，避免同一段全局记忆在上下文里出现两次）。
+ * 返回值**只含该工作流维度的那一段**（全局画像 / 全局别名由入口的无参
+ * `workflow.memoryPrompt` 覆盖，这里经 `extractWorkflowMemorySection` 裁掉，
+ * 避免同一段全局记忆在上下文里出现两次）。
  *
- * best-effort：读记忆失败（未开通记忆 / 接口不可用）不是错误——一律按新用户处理，
- * 只体现在 `launchPreferences.available` 上，绝不阻断表单载入（与 `workflow.memoryPrompt` 同口径）。
+ * best-effort：读不到（没开通记忆 / 404 / 接口故障）一律返回空串 —— 对模型而言
+ * 「没有记忆」和「读取失败」的处理完全一样（按新用户处理、不要重试），不需要再分档。
+ * 绝不阻断表单载入（与 `workflow.memoryPrompt` 同口径）。
  */
-async function fetchLaunchPreferences(workflowId, env) {
-    const result = { available: false, workflowId, promptText: '' };
+async function fetchWorkflowMemory(workflowId, env) {
     try {
         const response = await env.host.workflowRequest({
             method: 'POST',
@@ -1168,38 +1651,21 @@ async function fetchLaunchPreferences(workflowId, env) {
         });
         // 该接口原始返回是 {code,msg,status,data:"<markdown>",fail}，业务成功标志是 status/fail
         // **不是 success**——这里**不能**用 responseData 解包（会把 data 里的 markdown 当主体，
-        // 导致 promptText 恒空）。与 workflow.memoryPrompt 同源。
-        // 只认 `data`（字符串）作为偏好正文：**不回退 `msg`**——`msg` 里是「接口返回成功」这类
-        // 通用提示，回退它会让"没配记忆"的环境被读成有一条内容是"接口返回成功"的偏好。
+        // 导致正文恒空）。与 workflow.memoryPrompt 同源。
+        // 只认 `data`（字符串）作为正文：**不回退 `msg`**——`msg` 里是「接口返回成功」这类
+        // 通用提示，回退它会让"没配记忆"的环境被读成有一条内容是"接口返回成功"的记忆。
         const body = (response && typeof response === 'object' ? response : {});
-        const rawPromptText = typeof body.data === 'string' ? body.data.trim() : '';
-        const promptText = extractWorkflowMemorySection(rawPromptText, workflowId);
         const businessOk = body.fail !== true && body.status !== false && body.success !== false;
-        result.available = Boolean(businessOk && promptText);
-        result.promptText = promptText;
+        if (!businessOk)
+            return '';
+        const rawPromptText = typeof body.data === 'string' ? body.data.trim() : '';
+        return extractWorkflowMemorySection(rawPromptText, workflowId);
     }
-    catch (error) {
-        // 404 ＝ 该智能体/工作流还没有记忆条目（未开通记忆），属**正常的新用户状态**，不是失败：
-        // 保持 `available:false` + `promptText:''`，**不加任何"失败"提示**、也不阻断任务。
-        // 其它错误才提示"读取失败、按新用户处理"。
-        if (!isNotFoundError(error)) {
-            result.note = '该工作流的记忆偏好读取失败，按新用户处理，不要重试。';
-        }
+    catch {
+        // 404 ＝ 该工作流还没有记忆条目（未开通记忆）、其它错误 ＝ 接口不可用；
+        // 两者都按「没有记忆」处理，既不加提示也不阻断任务。
+        return '';
     }
-    return result;
-}
-/**
- * 是否是「资源不存在」类错误（HTTP 404）。
- *
- * 真机上该错误由 host 统一抛成 `workflowApiError('http_error', 'OA 接口 HTTP 404', {code:404, details:{status:404}})`，
- * 故同时认 `code` 与 `details.status` 两处。不依赖类实例判断，避免把跨包包装过的错误漏掉。
- */
-function isNotFoundError(error) {
-    const record = (error && typeof error === 'object') ? error : {};
-    if (Number(record.code) === 404)
-        return true;
-    const details = record.details;
-    return Boolean(details && typeof details === 'object' && Number(details.status) === 404);
 }
 // ---------------------------------------------------------------------------
 // createForm：解析工作流 + loadBase/loadFrame/loadMinor/formLayout + 字段输出
@@ -1271,19 +1737,99 @@ function singleExplicitWorkflowId(rawWorkflow) {
     const parsed = parseNameWithId(terms[0]);
     return parsed.id ?? (/^[0-9]+$/.test(terms[0]) ? terms[0] : '');
 }
-/** 表单载入 + 该工作流的发起偏好：两者只共享 `workflowId`，可以并行。 */
+/** 表单载入 + 该工作流的记忆：两者只共享 `workflowId`，可以并行。 */
 async function loadCreateFormPack(workflowId, env) {
-    const [{ data }, launchPreferences] = await Promise.all([
+    const [{ data }, workflowMemory] = await Promise.all([
         buildCreateFormData(workflowId, env),
         // 记忆读取是 best-effort（内部全 catch），不会把表单载入的错误顶掉。
-        fetchLaunchPreferences(workflowId, env),
+        fetchWorkflowMemory(workflowId, env),
     ]);
-    return { data, launchPreferences };
+    return { data, workflowMemory };
 }
-async function commandCreateForm(args, env) {
+/**
+ * 智能填参：把「用户意图 + 表单字段上下文」交给独立智能体（`chatScene`），换回可直接使用的 `data`。
+ *
+ * ## 什么时候调
+ *
+ * 两个条件**同时**成立才调，缺一就原样返回（= 老行为）：
+ * 1. 调用方给了 `userQuestion`（非空）—— 空串时智能体没有可依据的意图，接口也回不出有效结果，
+ *    所以仍以它为前置（2026-10-20 用户裁定）；
+ * 2. 拿到了 `baseUrl`（真连上了 OA）。
+ *
+ * **不看小e 档**（2026-10-20 用户裁定）：以前这一档被跳过，理由是"填单发生在宿主页面、算了也没人用"；
+ * 现在照走 —— 走通时 `createForm` 直接把算好的 `data` 交给模型，页面填单同样能用上。
+ *
+ * ## 失败怎么处理
+ *
+ * `requestFormFill` 内部吞掉所有异常并返回 `ok:false`，这里**直接不当回事**：返回
+ * `applied:false`，调用方照旧回 `historyRequestData` / `systemFields`。智能体挂掉不能把
+ * 发起流程打死 —— 这是本功能唯一的硬约束。
+ *
+ * ## 传什么记忆
+ *
+ * `userMemory` 用该工作流的记忆（`workflowMemory`）。它是
+ * **一段 Markdown 文本**，不是键值对象（2026-10-19 用户裁定）。全局画像由入口处的
+ * `workflow.memoryPrompt` 覆盖，这里不重复取。
+ */
+async function resolveIntentFill(pack, userQuestion, baseUrl, env) {
+    const question = String(userQuestion ?? '').trim();
+    // ★ 2026-10-20 用户裁定（口径修正）：前置**只有两条** ——「`userQuestion` 非空」+「连上了 OA」。
+    // `userQuestion` 为空时智能体没有可依据的意图、接口也回不出有效结果，故照旧不调；
+    // **小e 档不再豁免**（此前 `hasXiaoEEnv` 直接关掉这条链路，现已按用户要求去掉）。
+    // 走通与否仍由接口结果决定：回不出可用的 `data.chatMessage.content`（JSON）就 `applied:false`。
+    if (!question || !baseUrl)
+        return { applied: false };
+    const fields = Array.isArray(pack.data.fields) ? pack.data.fields : [];
+    if (!fields.length)
+        return { applied: false };
+    const input = buildChatSceneInput({
+        userQuestion: question,
+        workflow: {
+            id: String(pack.data.workflow?.id ?? ''),
+            name: String(pack.data.workflow?.name ?? ''),
+        },
+        fields,
+        historyRequestData: pack.data.historyRequestData ?? null,
+        systemFields: pack.data.systemFields ?? {},
+        userMemory: String(pack.workflowMemory ?? ''),
+        now: formatLocalNow(),
+    });
+    const outcome = await requestFormFill(env, input);
+    if (!outcome.ok || !outcome.data)
+        return { applied: false };
+    return {
+        applied: true,
+        data: outcome.data,
+        // 智能体的标题规则：有默认值时它只会给空串（沿用默认）；给了值才是用户明确要求的标题
+        requestName: String(outcome.systemData?.requestName ?? '').trim(),
+        // 供 `createRequestDirect` 把「紧急程度 / 密级 / 签字意见」一并透传给 `createRequest`；
+        // `createForm` 自己不消费这几个键（返回面一个字不变）。
+        systemData: outcome.systemData ?? {},
+        // ★ 2026-10-19 用户裁定：把「生成表单参数」这段的耗时单独带出去（只在真走通 chatScene 时才有）。
+        // 口径 = `requestFormFill` 内部这一趟（发请求 → 拿回 content → parse → 归一化），
+        // 不含本函数上游的会话初始化与表单取数 —— 那些已由 `durationMs` 计入，两者是「整条命令」与
+        // 「其中智能体这一段」的关系，不是并列的两笔开销。
+        durationMs: outcome.durationMs,
+    };
+}
+/**
+ * `createForm` 的**取数阶段**（原 `commandCreateForm` 前半段，逐行搬过来，行为一字不改）。
+ *
+ * 抽出来的唯一目的：`createRequestDirect` 需要「未经压缩、未经落盘」的原始 payload —— 那条命令要把
+ * `contextId` 与智能体算出的 `data` 直接喂给 `createRequest`，而 `commandCreateForm` 的输出可能
+ * 因为超线只剩一句"结果已落盘"的提示，取不到这两个键。
+ */
+async function prepareCreateFormPayload(args, env) {
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
     // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
-    await env.host.getSession();
+    // 顺带留住返回的上下文：智能填参要用它的 `baseUrl` 判「是不是真连了 OA」。
+    //
+    // 顺带计时：登录取凭据（小e 环境下是 `tokens.py` 换 eteamId + `teamsCheck` 换登录人这一整套）
+    // 走的是 auth 层自己的 fetch，不经 `host.workflowRequest` ⇒ 天然落在 `apiDurations` 之外。
+    // 这一段的耗时单独带出去（`authMs`），否则「总耗时 − 各接口」会凭空多出几百毫秒对不上账。
+    const authStartedAt = Date.now();
+    const sessionCtx = await env.host.getSession();
+    const authMs = Date.now() - authStartedAt;
     let target;
     let pack;
     const explicitId = singleExplicitWorkflowId(args.workflow);
@@ -1299,11 +1845,99 @@ async function commandCreateForm(args, env) {
         target = await resolveCreateWorkflow(args.workflow, env);
         pack = await loadCreateFormPack(target.id, env);
     }
-    return workflowSuccess('workflow.createForm', await compactFormOutput({
+    // ★ 2026-10-15 用户裁定：`createForm` 改用**字符口径 20,000** 的**严格档**（见
+    // `CREATE_FORM_STDOUT_SAFE_CHARS` / `compactFormOutput` 的 `charBudget`）。
+    //
+    // 与 2026-10-13/14 那两轮「超线仍回挂 `contextId` / `fields` / `historyRequestData`」的口径**相反**：
+    // 超线时 stdout **只回那一句提示**，一个键都不回挂 —— 用户明确要求"不用再返回 json"，理由是那几样
+    // 在落盘文件里都能取到（含下一步 `createRequest` 要用的 `contextId`）。因此这里**不再传 `keep` 清单**，
+    // 键序契约（`contextId` → `fields` → `historyRequestData`）也随之失效、不必再维护。
+    //
+    // 判线量的是**最终打出去的那份文本**（`finalStdoutChars`：信封 + `fields` / `historyRequestData` /
+    // `systemFields` 的紧凑路径），不是美化 JSON —— 那三个键压成单行后整份实测小约 30%，用美化口径判线
+    // 会让本可内联的表单被判落盘。
+    //
+    // 未超线时 `fullPayload` 原样返回，行为与从前一致（只是 stdout 上那几个键改单行）；落盘那份**始终
+    // 完整**（pretty JSON，未紧凑），所以模型按提示读回来拿到的是与 stdout 同口径的全量内容。
+    //
+    // 显式标注为 `Record<string, any>`：`pack.data` 是带索引签名的宽松对象，而对象字面量里又显式写了
+    // `workflow`，TS 的推断会**丢掉索引签名**、只留这个显式键。
+    const fullPayload = {
         ...pack.data,
-        workflow: { ...(pack.data.workflow || {}), selectionSource: target.source },
-        launchPreferences: pack.launchPreferences,
-    }, env, 'last_create_form.json'));
+        workflow: {
+            ...(pack.data.workflow || {}),
+            selectionSource: target.source,
+            // ★ 2026-10-20 用户裁定：`from` **只在**「多候选按近一年发起记录推断出来」这一种场景出现，
+            // 其余场景一个字都不多（模型据此知道这个工作流是推断的，而不是用户明说的）。
+            ...(target.from ? { from: target.from } : {}),
+        },
+    };
+    // 该工作流的记忆：**一段 Markdown 原文**，读不到就不出这个键（模型见到"没有这个键"就按新用户处理）。
+    if (pack.workflowMemory)
+        fullPayload.workflowMemory = pack.workflowMemory;
+    // ★ 2026-10-19 用户裁定：`createForm` 在返回前调 `chatScene`，由独立智能体把用户意图直接算成
+    // `data` 参数。成功时返回面收窄为「记忆（workflowMemory）+ fields + data」：
+    //   - `historyRequestData` 删除（历史值已由智能体消化进 data，再发一份只会让模型二选一）
+    //   - `systemFields` / `systemFieldWarning` 删除（智能体已按默认值 + 选项约束算过标题与紧急程度）
+    //   - `requiredInfoWarning` **保留**：它不是 systemFields 的内容，而是「OA 没下发静态字段权限，
+    //     照常按 missingFields 补齐」这条**行为指引**；删掉会让模型在未下发权限的表单上误判。
+    // 失败（含小e 档、未传 userQuestion）⇒ 一个字都不改，原样走老口径。
+    const fill = await resolveIntentFill(pack, String(args.userQuestion ?? ''), sessionCtx.baseUrl, env);
+    if (fill.applied) {
+        delete fullPayload.historyRequestData;
+        delete fullPayload.systemFields;
+        delete fullPayload.systemFieldWarning;
+        fullPayload.data = fill.data;
+        // 智能体只在「用户明确要求标题」时才给非空值；它给了才覆盖 createForm 的默认标题
+        if (fill.requestName)
+            fullPayload.requestName = fill.requestName;
+    }
+    return { payload: fullPayload, fill, authMs };
+}
+async function commandCreateForm(args, env) {
+    // ★ 2026-10-16 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
+    // 起点取在函数入口（含下面那次会话惰性初始化），终点取在结果产出之后 —— 即"从命令开始执行到
+    // 执行完成"。取值不做开关、不进 skill 文档（用户明确要求"直接默认加上"）。
+    const startedAt = Date.now();
+    // ★ 2026-10-21 用户裁定：耗时口径与 `createRequestDirect` **完全一致** —— 除总耗时外再给
+    // 「每个接口多久」（`apiDurations`）与「登录取凭据多久」（`authMs`）。所以这里也把 host 包一层
+    // 逐接口计时，整条命令（含智能填参那一趟）的请求都会被记上。
+    const spans = [];
+    const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    const { payload: fullPayload, fill, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    // 取数阶段已全部结束 ⇒ 这里拿到的是完整的一份；它既是判线要预留的键，也是最终返回的值。
+    const apiDurations = summarizeApiSpans(spans);
+    // 判线的位数预留：`durationMs` / `apiDurations` / `authMs` 一定会有；`fillDurationMs` **只有走通
+    // chatScene 才有**，所以只在它会出现的这一轮才占位 —— 否则没走智能体时也白占十几个字符，边界上
+    // 会让本可内联的表单提前落盘。`apiDurations` 此刻已经求出，直接按真值占（不必用哨兵估）。
+    const reserve = {
+        durationMs: DURATION_RESERVE_SENTINEL,
+        apiDurations,
+        authMs: DURATION_RESERVE_SENTINEL,
+    };
+    if (fill.durationMs !== undefined)
+        reserve.fillDurationMs = DURATION_RESERVE_SENTINEL;
+    const compacted = await compactFormOutput(fullPayload, timedEnv, 'last_create_form.json', [], {
+        safeChars: CREATE_FORM_STDOUT_SAFE_CHARS,
+        operation: 'workflow.createForm',
+        // 判线要量"最终打出去的那份文本"，而 `durationMs` / `fillDurationMs` 的真值只能在压缩**之后**求
+        // （它们统计的正是这段时间），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘
+        // （安全方向）。
+        reserve,
+    });
+    // 耗时并在 `data` 里（与 `outputChars` / `persistedResult` 这些运行期属性同处）；**两条分支都带上**
+    // —— 超线落盘那一档 `data` 只剩一句提示，并进去它才不会恰好在"大表单"时消失。
+    const result = {
+        ...compacted,
+        durationMs: Date.now() - startedAt,
+        apiDurations,
+        authMs,
+    };
+    // `fillDurationMs`（生成表单参数的耗时）**只在真走通 chatScene 时出现**：失败降级走的是老口径，
+    // 返回面必须一个字都不多（对应需求「不符合预期则仍按原本逻辑执行和返回」）。
+    if (fill.durationMs !== undefined)
+        result.fillDurationMs = fill.durationMs;
+    return workflowSuccess('workflow.createForm', result);
 }
 // ---------------------------------------------------------------------------
 // createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
@@ -1317,6 +1951,15 @@ async function commandCreateForm(args, env) {
 async function buildCreateFormData(workflowId, env) {
     const query = { workflowId, isCreate: 1, ...AJAX_QUERY };
     const body = { workflowId, isCreate: 1, isMobile: 0 };
+    /**
+     * 历史参考值的**列表**请求提前发起（P2 提速，2026-10-13）：它只依赖 `workflowId`，与下面四个
+     * 表单载入接口没有任何数据依赖，所以放在这里和它们**并发**跑，不再等字段解析完再串行补一次列表
+     * （真机该请求 1–2 s，全落在关键路径上）。
+     *
+     * `.catch(() => null)` 是必须的：这个 Promise 可能因为表单后续抛错而**没人 await**，
+     * 兜住之后就不会留下未处理的拒绝；真要暴露的认证/网络错误由同批的载入请求抛出，不会被吞掉。
+     */
+    const historyListSnapshot = fetchHistoryListSnapshot(env, { workflowId }).catch(() => null);
     // 2026-09-22：这四个接口**彼此没有数据依赖**（入参只需要 workflowId，见各自的 query/body），
     // 真机实测各 171–429 ms、串行合计约 1.1 s；并行后只受最慢的一个约束。
     // `loadMinorInfo` / `tenant/setting` 仍是 best-effort（失败只降级、不阻断），所以各自 catch 成
@@ -1428,7 +2071,23 @@ async function buildCreateFormData(workflowId, env) {
     const systemFieldValues = _normalizeSystemFieldValues(layoutData.businessOperatorObj);
     let linkageActions = Array.isArray(layoutData.linkageActions) ? layoutData.linkageActions : [];
     let onLoadLinkage = [];
-    if (linkageActions.length) {
+    /**
+     * 小e 环境下**不跑 `onLoadForm` 字段联动**（2026-10-16 用户裁定）。
+     *
+     * 理由：小e 这一档的真正填单动作由宿主浏览器页面完成，`createForm` 只是给模型一份
+     * 「有哪些字段、默认值是多少」的快照；onLoadForm 联动**带出的值**在这一档用不上
+     * （真到表单页里，页面自己会把联动跑一遍）。省掉这一趟 `fdLinkage` 请求。
+     *
+     * ⚠️ **显示属性联动照跑**：紧接其后的 `computeLinkageVisibility` 数据源是响应里本地的
+     * `layoutData.viewLinkages`，不依赖本次联动结果；跳过字段联动后它按「表单默认值 + 系统字段值」
+     * 求值，`fields` 里的隐藏 / 只读 / 条件必填判定仍然成立。
+     *
+     * `linkageActions` 仍原样随句柄带给 `createRequest`（非小e 环境下那一侧自己会跑联动，见
+     * `commandCreateRequest`），本处跳过的只是 `createForm` 自己发起的这一次 onLoadForm 调用。
+     * 小e 环境下两处都不跑（`createRequest` 同档也跳过字段联动与显示属性联动，由浏览器页面自己算）。
+     * 非小e 环境行为不变。
+     */
+    if (!hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.()) && linkageActions.length) {
         const loadEntries = _entriesFromDefaults(defaults);
         try {
             onLoadLinkage = await runFieldLinkage(env, buildLinkageContext({ runtime, frame, layout: { form_id: frame.form_id }, linkageActions }), loadEntries, new Set(['onLoadForm']), defaults);
@@ -1502,8 +2161,60 @@ async function buildCreateFormData(workflowId, env) {
             }
         }
     }
+    /**
+     * 模型真正需要关心的字段 = **必填字段** ∪ **用户实际能在表单上看到的可编辑字段**。
+     *
+     * 2026-10-14 用户裁定：`createForm` 下发的字段信息（`fields`）与历史数据参考
+     * （`historyRequestData`）都只保留这两类。此前 `fields` 下发的是"布局级字段全集"
+     * （真机 277 条，其中 145 条是只读 / 不可编辑 / 不在当前布局上的字段），模型既看不到也填不了，
+     * 只能逐条扫过去白花上下文。
+     *
+     * 口径来源就是上面两轮循环已经算好的四份清单（主表必填 / 主表可写 / 明细必填 / 明细联动必填）——
+     * 它们本身已过「非只读且可写」「未被联动隐藏」「在当前布局的展示配置内」三道筛，不另立判据。
+     */
+    const modelFieldIds = new Set();
+    for (const list of [requiredFieldsList, editableFieldsList, ...Object.values(subFormRequired), ...Object.values(subFormLinkageRequired)]) {
+        for (const item of list) {
+            const id = String(item?.id ?? '');
+            if (id)
+                modelFieldIds.add(id);
+        }
+    }
+    /**
+     * 字段默认值（`initialValue`）——「有默认值的字段直接把值挂在字段属性上」（2026-10-14 用户裁定）。
+     *
+     * 取代此前两条输出面：独立的 `initialValues` 数组、以及 `fillPlan` 里的 `defaulted` 标记。
+     * 口径不变（`hiddenCellIds` / `modelFieldIds` / 布局展示配置三道筛，与 `fields` 同源），
+     * 只是换了落点：模型看某个字段时，默认值就在它旁边，不必再跨键对照两份清单。
+     * 同一字段有多条默认值时取第一条（与旧 `initialValues` 的逐条追加相比，「哪个是新值」旧口径
+     * 本就无法判定，取首条至少是确定性的）。
+     */
+    const initialValueByFieldId = new Map();
+    for (const d of defaults) {
+        const fid = String((d.formField && d.formField.id) ?? '').trim();
+        if (!fid || hiddenCellIds.has(fid) || initialValueByFieldId.has(fid))
+            continue;
+        if (!modelFieldIds.has(fid))
+            continue;
+        const sf = String((d.subForm && d.subForm.id) ?? '').trim();
+        if (sf) {
+            if (layoutSubformIds.size && !layoutSubformIds.has(sf))
+                continue;
+        }
+        else if (compsFieldIds.size && !compsFieldIds.has(fid)) {
+            continue;
+        }
+        const disp = _detailDisplayText(d);
+        if (!disp)
+            continue;
+        initialValueByFieldId.set(fid, disp);
+    }
     const slimFields = [];
     for (const field of visibleFields) {
+        // 只下发模型需要关心的字段（可编辑 ∪ 必填且可见，见 modelFieldIds 注释）；只读 / 联动隐藏 /
+        // 不在当前布局上的字段不下发——模型既填不了也看不到。
+        if (!modelFieldIds.has(String(field.id ?? '')))
+            continue;
         // 键序 id|name|subFormId|componentKey 是契约；`subFormId` **为空就整个省略**（缺该键＝主表字段）
         // —— 主表字段占绝大多数，写 `""` 恒白占一条键（真机 278 字段表单：100 个主表字段 × 22 B ≈ 2.2 KB）。
         const slimSubFormId = String(field.subFormId ?? '');
@@ -1511,9 +2222,15 @@ async function buildCreateFormData(workflowId, env) {
         if (slimSubFormId)
             item.subFormId = slimSubFormId;
         item.componentKey = field.componentKey;
-        // `fields` **不返回** `required`：必填只从 `requiredFields`（主表）/ `subFormRequired`（明细）取。
-        // `fields` 是布局级字段全集（含联动隐藏、未在当前页展示的字段），在这里标必填会让模型
-        // 拿它去推演"能填什么 / 哪些是必填"，与真实可填集合（`editableFields`）混淆。
+        // 表单初始化时就有的值（OA 预填 + onLoadForm 联动带出）——有才出现该键；**没有默认值的字段不带**。
+        // CLI 拼 `data` 时会自动并入，模型**不必显式传**；用户本次明确改写了它才按用户说的覆盖（见
+        // `workflow-create.md` 的「填值纪律」）。
+        const initialValue = initialValueByFieldId.get(String(field.id ?? ''));
+        if (initialValue !== undefined)
+            item.initialValue = initialValue;
+        // `fields` **不返回** `required`（2026-10-14 起也不再区分必填/可写）：本清单就是「可编辑 ∪ 必填且
+        // 可见」的全集，能出现在这里就是能填的字段；必填与否最终只由 `createRequest` 的 `missingFields`
+        // 说了算。标 `required` 只会让模型拿它去推演"哪些是必填"，与 `missingFields` 形成双份口径。
         if (field.readOnly || field.disableEdit) {
             item.readOnly = Boolean(field.readOnly);
             item.disableEdit = Boolean(field.disableEdit);
@@ -1558,28 +2275,6 @@ async function buildCreateFormData(workflowId, env) {
     const fieldsById = new Map();
     for (const f of fields)
         fieldsById.set(String(f.id ?? ''), f);
-    const initValues = [];
-    for (const d of defaults) {
-        const fid = String((d.formField && d.formField.id) ?? '').trim();
-        if (!fid || hiddenCellIds.has(fid))
-            continue;
-        const sf = String((d.subForm && d.subForm.id) ?? '').trim();
-        if (sf) {
-            if (layoutSubformIds.size && !layoutSubformIds.has(sf))
-                continue;
-        }
-        else if (compsFieldIds.size && !compsFieldIds.has(fid)) {
-            continue;
-        }
-        const disp = _detailDisplayText(d);
-        if (!disp)
-            continue;
-        const f = fieldsById.get(fid) || {};
-        const iv = { fieldId: fid, name: f.name ?? fid, value: disp };
-        if (sf)
-            iv.subFormId = sf;
-        initValues.push(iv);
-    }
     /**
      * 必填字段 → 历史可参考值（V12.1.77：取数点从 `createRequest` **前移到这里**）。
      *
@@ -1602,7 +2297,9 @@ async function buildCreateFormData(workflowId, env) {
             ...Object.values(subFormRequired).flatMap((list) => list.map((f) => String(f?.id ?? ''))),
         ].filter(Boolean))];
     const historyCache = fields.length
-        ? await buildHistoryRequestData(env, fields, historyRequiredFieldIds.map((id) => ({ id, name: String((fieldsById.get(id) || {}).name ?? id) })), { allFormFields: true, workflowId })
+        ? await buildHistoryRequestData(env, fields, historyRequiredFieldIds.map((id) => ({ id, name: String((fieldsById.get(id) || {}).name ?? id) })), { allFormFields: true, workflowId }, 
+        // 本命令开头就已并发发起的列表请求：这里只补「详情」那几步（P2）。
+        historyListSnapshot)
         : null;
     const session = await getSessionContext(env);
     const context = {
@@ -1651,31 +2348,25 @@ async function buildCreateFormData(workflowId, env) {
         historyRequiredFieldIds,
     };
     const token = await env.continuation.issue({ operation: 'workflow.createForm', baseUrl: session.baseUrl, profile: session.profile, userId: session.userId, payload: context }, CONTINUATION_TTL_MS);
-    const requiredFieldIds = requiredFieldsWithSystem(requiredFieldsList, runtime, minorInfo.permissions || {});
     return {
         data: {
             status: 'FORM_READY',
             contextId: token,
             requestId: runtime.request_id,
-            // 显式点名语义：createForm 阶段并没有建单，这个 ID 是**预生成**的流程请求 ID，
-            // 只作为该单据的身份标识随 context 带到 createRequest；不写清楚模型会误当成"已存在的流程编号/草稿号"。
-            requestIdDesc: '预生成的流程请求 ID：本阶段尚未创建流程，它只是这次将要创建的单据的身份标识（用于后续 createRequest），不是已存在的流程编号或草稿号。',
             requestName: runtime.default_request_name || '',
             workflow: context.workflow,
             form: { id: frame.form_id, layout_id: layoutId },
-            requiredFields: requiredFieldIds,
-            subFormRequired: Object.fromEntries(Object.entries(subFormRequired).map(([k, v]) => [k, v.map((f) => String(f.id ?? ''))])),
-            // `editableFields` = 「非必填的可写字段」∪「`requiredFields`」——必填字段同样是可写字段，
-            // 模型按本清单拼 `data` 时不必再去 `requiredFields` 里二次查一遍（明细必填见 `subFormRequired`）。
-            editableFields: [...new Set([
-                    ...editableFieldsList.map((f) => String(f.id ?? '')),
-                    ...requiredFieldIds.map((id) => String(id ?? '')),
-                ].filter(Boolean))],
+            // 字段清单（**唯一**一份，2026-10-14 用户裁定）：可编辑字段 ∪ 必填且可见字段；有默认值的字段
+            // 直接带 `initialValue`。此前并列的 `requiredFields` / `subFormRequired` / `editableFields` /
+            // `initialValues` 四份清单与 `fillPlan` 一并取消——它们与 `fields` 同源、只是换个维度再切一刀，
+            // 模型却要跨五份清单对照同一个字段。现在的口径只有两句：
+            //   「哪些字段可以落值」= 本清单（能出现在这里就是能填的）；
+            //   「哪个必填还没值」= `createRequest` 的 `missingFields`（唯一权威，本命令不下发必填标记）。
             fields: slimFields,
-            initialValues: initValues,
-            // 本表单**必填字段**的历史参考值（近一年、非草稿、最近 5 条「我发起的」）——填值前先看它，
-            // 能直接照用的字段就别去问用户。完整结果（含非必填字段）已随句柄留给 `createRequest` 用。
-            historyRequestData: filterHistoryRequestData(historyCache, historyRequiredFieldIds),
+            // 历史参考值（近一年、非草稿、最近 5 条「我发起的」）——填值前先看它，能直接照用的字段就别去
+            // 问用户。字段范围与 `fields` **同一口径**（见 modelFieldIds 注释）；完整结果（本表单全部字段）
+            // 仍随句柄留给 `createRequest` 用（条件必填要到那边才现身）。
+            historyRequestData: filterHistoryRequestData(historyCache, modelFieldIds),
             systemFields: {
                 permissions: minorInfo.permissions || {},
                 defaults: context.systemFields.defaults,
@@ -1912,6 +2603,23 @@ function splitValueAliases(raw) {
     }
     return out;
 }
+/**
+ * 一个格子要送去查候选的「说法」清单——**按字段是单选还是多选分叉**：
+ *
+ *   - **单选**：整串与各说法一并登记，由 `resolveBrowserAliases` 的「整串优先」先试整串
+ *     （名称本身自带逗号时不会被拆错）；
+ *   - **多选**：逗号是**值分隔符**，只拆不拼——整串既不做「整串优先」，也**不进候选池**。
+ *     否则「张三,李四」会被整串当成一个名称，恰好命中就静默吞成一个值（真机问题：
+ *     多选浏览字段只写进去第一个对象），而且还会白花一次 complete / nameToId 往返。
+ *
+ * 多选里若单个对象名真的自带逗号，由 `名称(ID)` 显式指定（`resolveBrowserAliases` 认它）。
+ */
+function lookupTermsOf(field, raw) {
+    const aliases = splitValueAliases(raw);
+    if (field && field.isMultiple)
+        return aliases.length ? aliases : [raw];
+    return aliases.length > 1 ? [raw, ...aliases] : [raw];
+}
 /** 浏览按钮字段解析不出来的统一出口。`candidates` **只含关键词真实命中**，绝不用首页枚举冒充。 */
 function browserAmbiguity(field, input, hits) {
     return new ValueAmbiguity({
@@ -1961,8 +2669,11 @@ function resolveBrowserAliases(field, raw, lookup) {
         return out;
     };
     const aliases = splitValueAliases(raw);
-    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定
-    const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定。
+    // 多选字段只登记切段结果（见 lookupTermsOf）。
+    const terms = lookupTermsOf(field, raw);
+    /** 「整串优先」只对**单选**成立：多选里逗号是值分隔符，整串本身不是候选名称。 */
+    const wholeTermFirst = !(field && field.isMultiple) && aliases.length > 1;
     const pool = [];
     /** 每个词各自「字面同名」的候选（显式 ID 也算字面命中，它本来就是精确值）。 */
     const literalByTerm = new Map();
@@ -1975,8 +2686,8 @@ function resolveBrowserAliases(field, raw, lookup) {
         literalByTerm.set(term, candidates.filter((c) => String(c?.name ?? '') === term));
     }
     const poolHits = dedupe(pool);
-    // ① **整串优先**：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
-    if (aliases.length > 1) {
+    // ① **整串优先**（仅单选）：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
+    if (wholeTermFirst) {
         const wholeHits = dedupe(literalByTerm.get(raw) || []);
         if (wholeHits.length === 1)
             return wholeHits[0];
@@ -2000,6 +2711,119 @@ function normalizeRelateCandidate(value) {
     const name = String(value.name ?? '').trim();
     return id && name ? { id, name } : null;
 }
+/** 需要按 `format` 归一化取值的日期 / 时间类控件（componentKey 已小写）。 */
+const DATE_COMPONENTS = new Set(['datecomponent', 'datetimecomponent', 'timecomponent', 'dateinterval']);
+/**
+ * 从模型给的文本里解析日期 / 时间分量。认得下面这些写法（全角数字先转半角）：
+ * `2026-08-21` / `2026/8/21` / `2026.8.21` / `2026年8月21日` / `20260821`、
+ * `09:00` / `9:5` / `9时30分` / `2026-08-21 09:00:30` / `20260821090030`、单挂一个裸数字（按小时）。
+ * 解析不出任何分量时返回 `null`（调用方原样透传，不猜）。
+ */
+function parseDateParts(raw) {
+    const text = String(raw ?? '')
+        .replace(/[０-９]/g, (c) => String.fromCharCode(c.charCodeAt(0) - 0xfee0))
+        .trim();
+    if (!text)
+        return null;
+    const parts = {};
+    // ① 紧凑写法：20260821 / 20260821093000
+    const compact = /^(\d{4})(\d{2})(\d{2})(?:[T\s]?(\d{2})(\d{2})(\d{2})?)?$/.exec(text);
+    if (compact) {
+        parts.y = Number(compact[1]);
+        parts.m = Number(compact[2]);
+        parts.d = Number(compact[3]);
+        if (compact[4] !== undefined) {
+            parts.hh = Number(compact[4]);
+            parts.mm = Number(compact[5]);
+        }
+        if (compact[6] !== undefined)
+            parts.ss = Number(compact[6]);
+        return parts;
+    }
+    // ② 日期段：年月日之间允许 - / . 或「年」「月」，日期后允许「日」「号」
+    let rest = text;
+    const dateMatch = /(\d{4})\s*[-/.年]\s*(\d{1,2})\s*[-/.月]\s*(\d{1,2})\s*[日号]?/.exec(rest);
+    if (dateMatch) {
+        parts.y = Number(dateMatch[1]);
+        parts.m = Number(dateMatch[2]);
+        parts.d = Number(dateMatch[3]);
+        rest = rest.slice(0, dateMatch.index) + rest.slice(dateMatch.index + dateMatch[0].length);
+    }
+    // ③ 时间段：时[:时分][:秒][.毫秒]，分隔符认 : ： 时 点 ，秒可带「分」「秒」
+    const timeMatch = /(\d{1,2})\s*[:：时点]\s*(\d{1,2})(?:\s*[:：分]\s*(\d{1,2}))?(?:\s*[.．]\s*(\d{1,3}))?/.exec(rest);
+    if (timeMatch) {
+        parts.hh = Number(timeMatch[1]);
+        parts.mm = Number(timeMatch[2]);
+        if (timeMatch[3] !== undefined)
+            parts.ss = Number(timeMatch[3]);
+        if (timeMatch[4] !== undefined)
+            parts.ms = Number(timeMatch[4]);
+    }
+    if (parts.y === undefined && parts.hh === undefined) {
+        // 兜底：整串只剩一个裸数字 ⇒ 当小时用（`format: HH` 场景，如 "9"）
+        const bare = /^(\d{1,2})$/.exec(rest.trim());
+        if (!bare)
+            return null;
+        parts.hh = Number(bare[1]);
+    }
+    return parts;
+}
+/**
+ * 按字段 `format` 归一化日期 / 时间文本（V12.1.115，2026-10-14 用户裁定）。
+ *
+ * 目标：**模型不必关心 `format`**。`2026-8-21`、`2026/08/21`、`2026年8月21日 9:5`、
+ * `2026-08-21 09:00:00` 都会落到 `format` 要求的形状——
+ * - `format` 里有的分量由解析结果补零后填（`yyyy-MM-dd` ⇒ `2026-08-21`）；
+ * - 时间分量没解析出来时补 `00`（`yyyy-MM-dd HH:mm` 收到纯日期 ⇒ `2026-08-21 00:00`），
+ *   这也是此前 `DATETIME_FORMAT` 报错那条路径的替代：不再要求模型补时间；
+ * - `format` 里没有的分量直接丢掉（`yyyy-MM-dd` 收到带时分秒的写法 ⇒ 只留日期）。
+ *
+ * 两条**不猜**的边界（宁可原样透传给服务端报错，也不编造用户没给的信息）：
+ * ① 解析不出任何分量（不是日期/时间文本）；② `format` 要日期、但文本里连年月日都没凑齐。
+ */
+function normalizeDateValue(raw, format) {
+    const text = String(raw ?? '').trim();
+    if (!text || !format)
+        return raw;
+    // 日期区间（`2026-08-01~2026-08-31` / 「…至…」）：两半各自归一化后按原分隔符接回。
+    for (const sep of ['~', '至']) {
+        if (text.includes(sep)) {
+            const halves = text.split(sep);
+            if (halves.length === 2)
+                return `${normalizeDateValue(halves[0], format)}${sep}${normalizeDateValue(halves[1], format)}`;
+        }
+    }
+    const parts = parseDateParts(text);
+    if (!parts)
+        return text;
+    // `format` 要哪个日期分量，文本里就得有哪个——缺了不猜（补 `01` 等于编造用户没给的日期）。
+    if ((/y{2,4}/.test(format) && parts.y === undefined)
+        || (/M/.test(format) && parts.m === undefined)
+        || (/d/.test(format) && parts.d === undefined)) {
+        return text;
+    }
+    const pad = (n, len = 2) => String(n).padStart(len, '0');
+    return format.replace(/yyyy|yy|MM|dd|HH|hh|mm|ss|fff|M|d|H|h|m|s|f/g, (token) => {
+        switch (token) {
+            case 'yyyy': return pad(parts.y ?? 0, 4);
+            case 'yy': return pad((parts.y ?? 0) % 100);
+            case 'MM': return pad(parts.m ?? 0);
+            case 'M': return String(parts.m ?? 0);
+            case 'dd': return pad(parts.d ?? 0);
+            case 'd': return String(parts.d ?? 0);
+            case 'HH':
+            case 'hh': return pad(parts.hh ?? 0);
+            case 'H':
+            case 'h': return String(parts.hh ?? 0);
+            case 'mm': return pad(parts.mm ?? 0);
+            case 'm': return String(parts.mm ?? 0);
+            case 'ss': return pad(parts.ss ?? 0);
+            case 's': return String(parts.ss ?? 0);
+            case 'fff': return pad(parts.ms ?? 0, 3);
+            default: return String(parts.ms ?? 0); // 'f'
+        }
+    });
+}
 function serializeValue(field, value, mappings, row, browserHints = {}) {
     const detail = { ...(row || {}), formField: { id: field.id } };
     const isEmployeeScope = field.isEmployeeScope || String(field.componentKey ?? '').toLowerCase() === 'employeescope';
@@ -2106,6 +2930,18 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 const key = `${field.id}_${rowIndex}_${term}`;
                 return { mapped: mappings[key] || [], completed: browserHints[key] || [] };
             };
+            if (field.isMultiple) {
+                // 多选：一个格子里的逗号是**值分隔符**，逐说法各解析出一条 `dataOptions`
+                // （整串不当名称，见 lookupTermsOf）。某个说法有歧义时整条值都不落地，
+                // 由该说法自己的候选澄清——已解析出的兄弟值**不丢**，因为澄清后会整条重发。
+                for (const term of lookupTermsOf(field, raw)) {
+                    const pickedOne = resolveBrowserAliases(field, term, lookup);
+                    if (options.some((o) => o.optionId === pickedOne.id))
+                        continue;
+                    options.push({ optionId: pickedOne.id, content: pickedOne.name });
+                }
+                continue;
+            }
             const picked = resolveBrowserAliases(field, raw, lookup);
             options.push({ optionId: picked.id, content: picked.name });
         }
@@ -2122,7 +2958,16 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 continue;
             }
             const keyword = String(item).trim();
-            const matches = choices.filter((c) => String(c.id) === keyword || String(c.name ?? '').toLowerCase() === keyword.toLowerCase());
+            // 选项值允许「名称(ID)」形态：模型会把澄清候选 / 历史参考值里的 `名称(ID)` 原样回传，
+            // 而契约（`workflow-create.md`「字段值格式」）只要求传 name ⇒ 必须容错，不能报 NOT_FOUND。
+            // **ID 取最后一个括号内的内容**：选项名自身可能带括号——真机如 `银行（个人报销）(7)`，
+            // 取第一个括号会得到 `个人报销` 这种非数字片段。口径复用 `parseNameWithId`（同一份正则，
+            // 避免"查询侧认、发起侧不认"的口径分叉），显式 ID 命中即直取，否则回落到名称精确比对。
+            const parsed = parseNameWithId(keyword);
+            const explicit = parsed.id ? choices.filter((c) => String(c.id) === parsed.id) : [];
+            const matches = explicit.length
+                ? explicit
+                : choices.filter((c) => String(c.id) === keyword || String(c.name ?? '').toLowerCase() === parsed.name.toLowerCase());
             if (matches.length !== 1) {
                 throw new ValueAmbiguity({
                     kind: 'OPTION',
@@ -2146,12 +2991,13 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
     if (value && typeof value === 'object') {
         throw new ValueAmbiguity({ kind: 'VALUE_FORMAT', fieldId: field.id, fieldName: field.name, reason: '文本字段只接受字符串、数字或布尔值', candidates: [] });
     }
-    const content = value === null || value === undefined ? '' : String(value);
-    const dateFormat = String(field.format ?? '');
-    const needsTime = dateFormat && /(HH|hh)[:：.]?mm|H:mm|h:mm/i.test(dateFormat);
-    if (needsTime && /^\d{4}-\d{1,2}-\d{1,2}$/.test(content)) {
-        throw new ValueAmbiguity({ kind: 'DATETIME_FORMAT', fieldId: field.id, fieldName: field.name, input: content, reason: `该字段是日期+时间控件（format=${dateFormat}），只传日期不完整；请按 format 传完整值（如 2026-08-21 09:00）后重新 prepare，不要省略时间。`, candidates: [] });
-    }
+    const rawContent = value === null || value === undefined ? '' : String(value);
+    // 日期 / 时间控件：模型给的写法一律在 CLI 内按字段 `format` 归一化（2026-10-14 用户裁定）。
+    // 此前这里在"日期+时间控件只收到纯日期"时抛 `DATETIME_FORMAT` 让模型补时间——把格式这件事
+    // 外包给了模型，实测它会为 `100` 还是 `100.00`、`09:00` 还是 `9:00` 反复纠结。
+    const content = DATE_COMPONENTS.has(component)
+        ? normalizeDateValue(rawContent, String(field.format ?? ''))
+        : rawContent;
     const maxLength = field.maxLength;
     const richUnlimited = component === 'textarea' && Boolean(field.richEditor);
     if (!richUnlimited && maxLength !== undefined && maxLength !== null && String(maxLength).match(/^\d+$/) && content.length > Number(maxLength)) {
@@ -2314,8 +3160,8 @@ async function resolveEntryValues(env, entries, formId) {
                 continue;
             // 一个格子可写多个「说法」（逗号分隔）：**整串与各说法一起登记**——这样"整串优先"要用的
             // 整串候选、以及各说法各自的候选，都在同一批里拿到（nameToId 一把批量发，未命中的再并行补）。
-            const aliases = splitValueAliases(raw);
-            const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+            // 多选字段只登记切段结果（逗号是值分隔符，见 lookupTermsOf）。
+            const terms = lookupTermsOf(field, raw);
             // 候选来源二选一：控件自带 `browserModule`+`browserType` ⇒ 只走 complete（下一步补查），
             // **不进 nameToId 批次**；否则只走 nameToId。这样池子里永远只有一个来源，不会互相污染。
             const hasBrowserChannel = Boolean(field.browserModule && field.browserType);
@@ -2599,14 +3445,155 @@ function _detailValueIds(detail) {
         if (t)
             ids.push(t);
     }
-    for (const option of detail.dataOptions || []) {
-        if (option && typeof option === 'object' && option.optionId !== undefined && option.optionId !== null) {
-            const t = String(option.optionId).trim();
-            if (t)
-                ids.push(t);
-        }
+    for (const option of detail.dataOptions || []) {
+        if (option && typeof option === 'object' && option.optionId !== undefined && option.optionId !== null) {
+            const t = String(option.optionId).trim();
+            if (t)
+                ids.push(t);
+        }
+    }
+    return ids;
+}
+/**
+ * 把一个值拆成「可比 token」集合：`id` / `optionId` / `name` / `content`，以及去掉尾部
+ * `(id)` / `（id）` 后缀的纯文本。
+ *
+ * 为什么要拆：入参是**原始串**（`"银行（个人报销）(7)"`、`"20260999"`），基线是 **detail**
+ * （`dataOptions:[{optionId:'7',content:'银行（个人报销）'}]`、`{content:'20260999'}`），
+ * 直接比 `_entryValueIds` 与 `_detailValueIds` 会得到 `["银行（个人报销）(7)"]` vs
+ * `["银行（个人报销）","7"]` 这种必不相等的形状。取交集判等才不会误判成"变了"。
+ */
+function _pushComparableToken(tokens, raw) {
+    const text = String(raw ?? '').trim();
+    if (!text)
+        return;
+    tokens.add(text);
+    const matched = text.match(/^(.*?)\s*[（(]\s*([^（）()]*?)\s*[)）]$/);
+    if (matched) {
+        // 尾部括号里是 id 时（`银行（个人报销）(7)`、`泛微上海(100504500000311504)`）也要能对上
+        if (matched[1].trim())
+            tokens.add(matched[1].trim());
+        if (matched[2].trim())
+            tokens.add(matched[2].trim());
+    }
+}
+function _entryComparableTokens(source) {
+    const tokens = new Set();
+    for (const item of listValues(source)) {
+        if (item && typeof item === 'object') {
+            for (const key of ['id', 'optionId', 'value', 'name', 'content']) {
+                if (item[key] !== undefined && item[key] !== null)
+                    _pushComparableToken(tokens, item[key]);
+            }
+        }
+        else {
+            _pushComparableToken(tokens, item);
+        }
+    }
+    return tokens;
+}
+/** 基线 detail 的可比 token（与 `_entryComparableTokens` 同一套口径）。 */
+function _baselineComparableTokens(detail) {
+    const tokens = new Set();
+    if (detail && typeof detail === 'object') {
+        if (detail.content !== undefined && detail.content !== null)
+            _pushComparableToken(tokens, detail.content);
+        if (detail.dataText && typeof detail.dataText === 'object' && detail.dataText.content !== undefined) {
+            _pushComparableToken(tokens, detail.dataText.content);
+        }
+        for (const option of detail.dataOptions || []) {
+            if (!option || typeof option !== 'object')
+                continue;
+            if (option.optionId !== undefined && option.optionId !== null)
+                _pushComparableToken(tokens, option.optionId);
+            if (option.content !== undefined && option.content !== null)
+                _pushComparableToken(tokens, option.content);
+            if (option.name !== undefined && option.name !== null)
+                _pushComparableToken(tokens, option.name);
+        }
+    }
+    return tokens;
+}
+/**
+ * 入参这条值是否**与基线相同**（即"用户没动过"）。
+ *
+ * 判松不判严（任一 token 命中即算相同）：漏判"变了"只会少触发一次联动（页面语义本来就是
+ * 没变不触发）；误判"没变"则会把用户真实修改的字段跳过，风险更大，所以这里宁可宽。
+ * 基线里没有该字段 / 基线没值时一律视为"变了"（首次填写必须触发）。
+ */
+function _sameAsBaseline(entry, detail) {
+    const base = _baselineComparableTokens(detail);
+    if (!base.size)
+        return false;
+    const incoming = _entryComparableTokens(entry.value);
+    if (!incoming.size)
+        return false;
+    for (const token of incoming) {
+        if (base.has(token))
+            return true;
+    }
+    return false;
+}
+/**
+ * 「值真的变了的字段 id」——`changeField` 类联动的触发依据（2026-10-20 用户裁定）。
+ *
+ * 旧口径把**入参里出现的字段**一律当成变更字段（模拟页面 onchange），于是"把表单默认值原样
+ * 回传"会伪造出一次"用户修改"：真机坑是 `合同号=20260999`（= 该字段 `initialValue`）被
+ * `createForm.data` 带出来、又被整份回传给 `createRequest`，触发合同号的 changeField 联动，
+ * 服务端按合同重算 `相关客户` 等 7 个字段把 `相关客户` 置空 ⇒ 必填缺失。
+ *
+ * 现在的口径：**只有值与基线不同才算变更**。
+ * - 发起流程：基线 = 表单默认值（`context.defaults`）
+ * - 编辑流程：基线 = 编辑前的字段值（`context.currentDetails`，来自 edit-load 的 `dataDetails`）
+ *
+ * 明细行按 `(subFormId, dataIndex)` 定位基线；明细默认值常常没有行号，此时回落到"同字段任一基线"
+ * （见 `byField`）——宁可判"没变"，也不要让无行号的默认值把每一行都判成变更。
+ */
+function _changedFieldIds(entries, baseline) {
+    const byRow = new Map();
+    const byField = new Map();
+    const pushTo = (map, key, item) => {
+        const bucket = map.get(key);
+        if (bucket)
+            bucket.push(item);
+        else
+            map.set(key, [item]);
+    };
+    for (const detail of baseline || []) {
+        if (!detail || typeof detail !== 'object')
+            continue;
+        const fieldId = String((detail.formField && detail.formField.id) ?? '').trim();
+        if (!fieldId)
+            continue;
+        const subFormId = String((detail.subForm && detail.subForm.id) ?? '').trim();
+        const hasRow = detail.dataIndex !== undefined && detail.dataIndex !== null;
+        const dataIndex = hasRow ? String(detail.dataIndex) : '';
+        pushTo(byField, fieldId, detail);
+        if (hasRow)
+            pushTo(byRow, `${subFormId}\u0000${fieldId}\u0000${dataIndex}`, detail);
+    }
+    const changed = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!entry.field || typeof entry.field !== 'object')
+            continue;
+        const fieldId = String(entry.field.id ?? '').trim();
+        if (!fieldId || seen.has(fieldId))
+            continue;
+        const row = (entry.row && typeof entry.row === 'object') ? entry.row : null;
+        const subFormId = row ? String((row.subForm && row.subForm.id) ?? '').trim() : String(entry.field.subFormId ?? '').trim();
+        const hasRow = Boolean(row) && row.dataIndex !== undefined && row.dataIndex !== null;
+        const candidates = hasRow
+            ? (byRow.get(`${subFormId}\u0000${fieldId}\u0000${String(row.dataIndex)}`) || [])
+            : (byField.get(fieldId) || []);
+        const fallback = hasRow ? (byField.get(fieldId) || []) : [];
+        const unchanged = [...candidates, ...fallback].some((detail) => _sameAsBaseline(entry, detail));
+        if (unchanged)
+            continue;
+        seen.add(fieldId);
+        changed.push(fieldId);
     }
-    return ids;
+    return changed;
 }
 function _linkageOptions(sourceContent) {
     if (!sourceContent || typeof sourceContent !== 'string' || !sourceContent.trim())
@@ -2732,9 +3719,10 @@ function _mainValueMap(details) {
     }
     return result;
 }
-async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false) {
-    const changedIds = entries.filter((e) => e.field && typeof e.field === 'object' && String(e.field.id ?? '').trim())
-        .map((e) => String(e.field.id));
+async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false, baseline) {
+    // 只有「值与基线（发起=表单默认值 / 编辑=编辑前值）不同」的字段才算变更字段，
+    // 见 `_changedFieldIds` 的注释（2026-10-20 用户裁定：值没变就不该触发 changeField 联动）。
+    const changedIds = _changedFieldIds(entries, baseline);
     const runDataList = _buildLinkageRunData(ctx.linkageActions, changedIds, actionTypes);
     const neededIds = _neededLinkageFieldIds(ctx.linkageActions, runDataList);
     const dataList = [];
@@ -2865,6 +3853,16 @@ function mergeLinkageDetails(merged, linkageDetails) {
     }
     return result;
 }
+/**
+ * `computeLinkageVisibility` 的空结果（四个集合都是空）。
+ *
+ * 用途：小e 档的 `createRequest` **不跑显示属性联动**（2026-10-16 用户裁定，见
+ * `commandCreateRequest`），此时直接取这份空结果顶替，避免调用点写四个字面量再补类型标注。
+ * 语义与 `computeLinkageVisibility` 的早退分支（`linkages` 不是数组时）完全一致。
+ */
+function emptyLinkageVisibility() {
+    return [new Set(), {}, {}, {}];
+}
 function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, systemFieldValues, fields) {
     const hiddenSubforms = new Set();
     const rowHidden = {};
@@ -3256,6 +4254,290 @@ function previewValueText(value) {
     }
     return value;
 }
+/** markdown 表格单元格：不能出现裸 `|` 与换行，否则列会错位（与 invoice 渲染档同口径）。 */
+function markdownCell(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw)
+        return '—';
+    return raw.replace(/\|/gu, '\\|').replace(/\r?\n/gu, ' ');
+}
+/**
+ * 缺失必填字段的**历史推荐值**（2026-10-13 用户口径）。
+ *
+ * 口径（用户原话："该字段历史数据填写值都一样，或者最近三条历史流程该字段值都一致"）：
+ * - 只看该字段**有值**的历史记录，顺序即 `historyCache` 的**发起时间倒序**；
+ * - 有值记录取值**全部一致** ⇒ 推荐；
+ * - 否则取**最近 3 条**有值记录，三者一致 ⇒ 推荐；
+ * - 其余一律**不给推荐**（宁缺勿错——让用户自己填，不猜）。
+ *
+ * 数据源是 `createForm` 随句柄留下的**宽缓存**（本表单全部字段），所以**联动命中后才变必填**的字段
+ * （真机样本里的「相关流程」）也能命中；句柄来自旧版本 / 缓存缺失时静默返回 `null`，不拖累主链路。
+ *
+ * **一致性判断完全在命令侧算完**：模型既不拿原始历史、也不做任何推断，只负责原样粘贴。
+ */
+function historyRecommendation(records, fieldId) {
+    const id = String(fieldId ?? '').trim();
+    if (!id)
+        return null;
+    const values = [];
+    for (const record of toArray(records)) {
+        // `fieldValues` 是 `{字段id: 值}` 映射（2026-10-15 起；旧形态是数组）。
+        const fieldValues = record?.fieldValues;
+        if (!fieldValues || typeof fieldValues !== 'object' || Array.isArray(fieldValues))
+            continue;
+        if (!Object.prototype.hasOwnProperty.call(fieldValues, id))
+            continue;
+        // 附件类字段的值是**结构化对象**（见 `formatHistoryFieldValue`）：`String()` 会把它压成
+        // `[object Object]`，于是 N 条互不相同的附件"看起来完全一致"⇒ 凭空给出一条假推荐。
+        // 非字符串一律不参与一致性判定（宁缺勿错）。
+        const raw = fieldValues[id];
+        if (typeof raw !== 'string')
+            continue;
+        const text = raw.trim();
+        if (text)
+            values.push(text);
+    }
+    if (!values.length)
+        return null;
+    if (values.every((value) => value === values[0])) {
+        return { value: values[0], note: `近 ${values.length} 条历史流程该字段取值一致` };
+    }
+    const latest = values.slice(0, 3);
+    if (latest.length === 3 && latest.every((value) => value === latest[0])) {
+        return { value: latest[0], note: '最近 3 条历史流程该字段取值一致' };
+    }
+    return null;
+}
+/** 选项清单里反查展示名（`紧急程度` / `密级` 的代码→中文名）。查不到返回空串。 */
+function optionDisplayName(options, value, idKeys) {
+    for (const item of toArray(options)) {
+        if (!item || typeof item !== 'object')
+            continue;
+        for (const key of idKeys) {
+            if (String(item[key] ?? '').trim() !== value)
+                continue;
+            return String(item.name ?? item.content ?? '').trim();
+        }
+    }
+    return '';
+}
+/**
+ * 系统字段（流程标题 / 紧急程度 / 密级）的「已填内容」行（2026-10-14 用户口径）。
+ *
+ * 流程标题**只要该次发起有值就列**（与上一版单独那行 `- **流程标题**：…` 同口径，只是换个位置）。
+ *
+ * 紧急程度 / 密级是本次新增，两条门槛**缺一不可**，否则一个字都不给（宁缺勿错）：
+ *   ① 服务端明确说该字段 `isview` —— `permissions` 里没有这一项时按"用户在表单上看不到"处理，
+ *      不给没有依据的行；
+ *   ② 该值能在 `level_options` / `sec_level_options` 里反查出中文名 —— 这两个控件在表单上是下拉框，
+ *      命令拿到的是**代码**（如密级 `1`）；直接印代码用户看不懂，宁可省略这一行。
+ */
+function systemFilledRows(params) {
+    const rows = [];
+    const title = String(params.title ?? '').trim();
+    if (title)
+        rows.push({ name: SYSTEM_FIELD_KEYS.REQUEST_NAMEL, value: title });
+    const push = (key, value, options, idKeys) => {
+        const perm = params.permissions[key] || {};
+        if (!perm.isview)
+            return;
+        const raw = String(value ?? '').trim();
+        if (!raw)
+            return;
+        const name = optionDisplayName(options, raw, idKeys);
+        if (!name)
+            return;
+        rows.push({ name: SYSTEM_FIELD_KEYS[key], value: name });
+    };
+    push('REQUEST_LEVEL', params.requestLevel, params.levelOptions, ['code', 'name']);
+    push('SECLEVEL', params.secLevel, params.secLevelOptions, ['id', 'name']);
+    return rows;
+}
+/**
+ * 「已填内容」**主表行**的唯一来源（2026-10-14 用户口径）：**用户在表单上能看到的、有值的、
+ * 可编辑的主表字段**，按**表单布局顺序**列出。
+ *
+ * 为什么不再只列"模型这次传了什么"：真的按 `resolvedValues`（= 仅本次入参）列时，用户看到的截图里
+ * 「已填内容」只剩下模型显式传的那两项 —— 而这张单在表单上其实是**已填状态**的：表单默认值、
+ * 系统字段一个都没列出来，用户根本无法据此确认"这张单到底填成什么样了"。
+ *
+ * 数据源是 `merged2` = 表单默认值 + 本次入参 + 联动带出的值，**就是将来真正落库的那一份**，
+ * 所以列出来的每个值都是"用户会在表单上看到的值"。
+ *
+ * 不列的五类（都按"用户在表单上看到的"口径筛）：
+ *   - 明细字段（另由明细表承载）、没值的字段（那是「还需要你提供」的活）；
+ *   - 只读 / 禁止编辑的字段（用户改不了，不算"可编辑字段"）；
+ *   - 联动隐藏、联动禁用、布局隐藏的字段；
+ *   - **布局隐藏行上的字段**（`Sheet1.rows[].visible === false`，见 `collectHiddenRowFieldIds`）；
+ *   - **不在这张表单组件清单里的字段**（`compsFieldIds` 是**白名单**：它列的是表单上真实摆着的
+ *     组件。E10 的老表单会在定义里留着"已废弃 / 换了控件"的历史字段，服务端照样下发它们的默认值，
+ *     但这些字段用户在表单上根本看不到 ⇒ 不进「已填内容」。这份名单与 `initialValues` 用的是同一份
+ *     ——`buildCreateFormData` 里的 `compsFieldIds.size && !compsFieldIds.has(fid)`，两边必须同口径，
+ *     否则模型看到的 `initialValues` 与命令渲染的「已填内容」会互相打架）。
+ *
+ * ⚠️ 2026-10-14 修正：本函数初版把这处写成 `compsFieldIds.has(fieldId) ⇒ 跳过`（白名单当黑名单用），
+ * 真机上结果**正好反过来**——列出来的全是用户看不到的老/隐藏字段（`币种（主表）2`、
+ * `账号企业个人类型（废弃）`、`创建人直接上级` …），真正填了的 `报销事由` 一个都没列。
+ * 单测没兜住是因为用例的 `compsFieldIds` 恒为 `[]`（空名单不筛），缺陷恰好落在空集上。
+ * **名单为空时（老句柄 / 布局解析失败）不筛**，与 `initialValues` 的降级口径一致。
+ *
+ * ⚠️ 2026-10-14 二次修正（用户口径）：`流程类型` 曾按**字段名**硬排除（`MAIN_FILLED_EXCLUDED_NAMES`），
+ * 那是因为当时只看到"它与普通业务 Select 逐键同形、载荷里无标记"。真实原因是**它落在隐藏行上**
+ * ——用户明确指出：这两个字段在表单上确实是显示的组件，但**所在行隐藏**，所以前台看不到。
+ * 按名排除已撤除，改由 `hiddenCellFieldIds`（含行隐藏）统一承载——换一张表单、换一个字段名同样成立。
+ */
+function mainFilledRows(fields, values, hiddenIds, disabledIds, compsFieldIds) {
+    const rows = [];
+    for (const field of toArray(fields)) {
+        if (!field || typeof field !== 'object')
+            continue;
+        const fieldId = String(field.id ?? '').trim();
+        if (!fieldId)
+            continue;
+        if (String(field.subFormId ?? '').trim())
+            continue;
+        if (field.readOnly || field.disableEdit)
+            continue;
+        if (hiddenIds.has(fieldId) || disabledIds.has(fieldId))
+            continue;
+        if (compsFieldIds.size && !compsFieldIds.has(fieldId))
+            continue;
+        const detail = values.get(fieldId);
+        if (!detail)
+            continue;
+        // 值必须走 `_detailDisplayText`（与 `initialValues` 的展示口径同源）：浏览/选项类在载荷里是
+        // `dataOptions`、富文本是 `dataText`，直接 `String()` 会印出 `[object Object]`。
+        const value = _detailDisplayText(detail);
+        if (!value)
+            continue;
+        rows.push({ name: String(field.name ?? fieldId), value });
+    }
+    return rows;
+}
+/**
+ * `createRequest` **已落地结果**的渲染档（与查询侧 `finalMarkdown` 同口径）：调用方
+ * **原样粘贴**即可——不必自己挑字段、拼表格，也不必判断该展示什么。
+ *
+ * 只在流程**已经落地**时渲染（`CREATED` / `CREATED_SUBMITTED` / `CREATED_SUBMIT_FAILED`）。
+ * `NEEDS_INPUT`（必填还没填齐）由 `renderCreatePendingMarkdown` 单独渲染——**刻意与本文本同一套
+ * 表格口径**，只换结论句与末段（那边要说清"还没发起 + 还差哪几项"）；`NEEDS_CONFIRMATION` 不给
+ * 文本（要先解决 `ambiguities` 再重发）。
+ *
+ * 内容分四段：结论（`message`，命令已写好的中文；**只用来渲染，渲染后这个键不再返回**）→ 编号/链接
+ * → 主表「已填内容」两列表
+ * （系统字段如流程标题在前，业务字段按表单布局顺序随后；行由 `mainFilledRows` + `systemFilledRows`
+ * 算好传进来，命令侧只有这一处口径）→ 各明细表（Excel 列形态）→ 提交失败原因 / 草稿缺项提醒（有才出现）。
+ */
+function renderCreateResultMarkdown(result, mainRows) {
+    const lines = [];
+    const message = String(result.message ?? '').trim();
+    if (message)
+        lines.push(message, '');
+    // 流程标题已并入「已填内容」第一行（2026-10-14 用户口径）：同一个值不在一份文本里出现两次。
+    const header = [
+        ['流程编号', result.requestMark || result.requestId],
+        ['流程链接', result.url],
+    ];
+    for (const [label, value] of header) {
+        const text = String(value ?? '').trim();
+        if (text)
+            lines.push(`- **${label}**：${text}`);
+    }
+    if (mainRows.length) {
+        lines.push('', '**已填内容**', '', '| 字段 | 值 |', '| --- | --- |');
+        for (const row of mainRows)
+            lines.push(`| ${markdownCell(row.name)} | ${markdownCell(row.value)} |`);
+    }
+    // 明细表：按列展示（Excel 列形态），多个子表单各成一表。
+    const groups = (result.previewDetails || []).filter((g) => (g?.columns || []).length);
+    groups.forEach((group, index) => {
+        const columns = group.columns;
+        lines.push('', groups.length > 1 ? `**明细表 ${index + 1}**` : '**明细表**', '', `| 序号 | ${columns.map((c) => markdownCell(c.fieldName)).join(' | ')} |`, `| --- | ${columns.map(() => '---').join(' | ')} |`);
+        (group.rows || []).forEach((row, rowIndex) => {
+            const values = (row?.values || []).map((v) => markdownCell(v));
+            lines.push(`| ${rowIndex + 1} | ${values.join(' | ')} |`);
+        });
+    });
+    const failReason = String(result.submitFailReason ?? '').trim();
+    if (failReason)
+        lines.push('', `**提交失败原因**：${failReason}`);
+    const notice = String(result.missingFieldsNotice ?? '').trim();
+    if (notice)
+        lines.push('', notice);
+    return lines.join('\n').trim();
+}
+/**
+ * `createRequest` **尚未发起**（`NEEDS_INPUT`：必填还没填齐）的渲染档：告诉用户"已填了什么、还差
+ * 哪几项"。与落地档（`renderCreateResultMarkdown`）**同一套表格口径**，调用方原样粘贴即可。
+ *
+ * 为什么要在命令里渲染（2026-10-13 真机）：让模型自己拿 `resolvedValues` 拼主表 + 明细表、再拼
+ * 待补清单，既慢又容易漂移；而且那样必须把 `resolvedValues` 一起返回，白占体积。渲染完就**不再
+ * 返回**那些中间结构（`resolvedValues` / `previewDetails`）。
+ *
+ * 内容分四段：结论（还差几项）→ 主表「已填内容」两列表（系统字段如流程标题在前、业务字段按表单
+ * 布局顺序随后，含表单默认值 —— 行由调用方算好传进来，与落地档共用同一份口径）→ 各明细表
+ * （Excel 列形态）→ 待补必填项清单（每项标出在主表还是明细第几行）。明细与主表**分开列**，与落地档同口径。
+ *
+ * 待补清单里，命令会为**历史取值一致**的字段补一行「历史推荐值」（口径见 `historyRecommendation`）——
+ * 用户据此可以一句话确认，不必先自己回想；推荐值由命令算好，模型不参与推断。
+ */
+function renderCreatePendingMarkdown(pending, mainRows, previewDetails, historyRecords, fieldMeta) {
+    const lines = [];
+    const missing = (pending.missingFields || []).filter(Boolean);
+    lines.push(`还没提交：还有 ${missing.length} 项必填没填，给齐后我直接提交。`);
+    if (mainRows.length) {
+        lines.push('', '**已填内容**', '', '| 字段 | 值 |', '| --- | --- |');
+        for (const row of mainRows) {
+            lines.push(`| ${markdownCell(row.name)} | ${markdownCell(row.value)} |`);
+        }
+    }
+    const groups = (previewDetails || []).filter((g) => (g?.columns || []).length);
+    groups.forEach((group, index) => {
+        const columns = group.columns;
+        lines.push('', groups.length > 1 ? `**明细表 ${index + 1}**` : '**明细表**', '', `| 序号 | ${columns.map((c) => markdownCell(c.fieldName)).join(' | ')} |`, `| --- | ${columns.map(() => '---').join(' | ')} |`);
+        (group.rows || []).forEach((row, rowIndex) => {
+            const values = (row?.values || []).map((v) => markdownCell(v));
+            lines.push(`| ${rowIndex + 1} | ${values.join(' | ')} |`);
+        });
+    });
+    if (missing.length) {
+        lines.push('', '**还需要你提供**', '');
+        missing.forEach((item, index) => {
+            const subFormId = String(item?.subFormId ?? '').trim();
+            const rowIndex = Number(item?.dataIndex);
+            const where = subFormId
+                ? `明细表第 ${Number.isFinite(rowIndex) && rowIndex > 0 ? rowIndex : 1} 行`
+                : '主表';
+            lines.push(`${index + 1}. **${markdownCell(item?.name ?? item?.id)}**（${where}）`);
+            const recommendation = historyRecommendation(historyRecords, String(item?.id ?? ''));
+            if (recommendation) {
+                lines.push(`   - 历史推荐值：${markdownCell(recommendation.value)}（${recommendation.note}）`);
+            }
+        });
+        // 缺项类型提示（2026-10-14 用户令）：缺项是**发票类 / 附件类**时，把"怎么把它给到"在渲染档里
+        // 一次说清。真机现场：这两类缺项会让模型在"要不要补一句提醒用户怎么给"上反复称量（思考链里
+        // 最长的尾巴就出在这里）——按本项目既有原则，把容易让模型绕圈的判断留在命令侧。
+        // 缺项可能不在 `fieldMeta` 里（联动命中后才新增的必填，不在 createForm 的静态快照里）：
+        // 判不出类型就不加，宁可少一句也不猜。
+        const metaById = new Map();
+        for (const meta of fieldMeta || [])
+            metaById.set(String(meta?.id ?? ''), meta);
+        const missingHas = (match) => missing.some((item) => {
+            const meta = metaById.get(String(item?.id ?? ''));
+            return !!meta && match(meta);
+        });
+        if (missingHas((meta) => meta.componentKey === 'EinvoiceComponent' || meta.isEinvoice === true)) {
+            lines.push('', '其中发票可以直接从你的票夹里选，也可以上传本地发票文件。');
+        }
+        if (missingHas((meta) => !!meta.fileUploadParams)) {
+            lines.push('', '附件需要上传本地文件。');
+        }
+    }
+    const linkage = String(pending.linkageResult ?? '').trim();
+    if (linkage)
+        lines.push('', linkage);
+    return lines.join('\n').trim();
+}
 function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, hiddenFieldIds, compsFieldIds, entries, layoutSubformIds) {
     if (!linkageDetails || !linkageDetails.length)
         return '';
@@ -3300,8 +4582,251 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
     return result;
 }
 // ---------------------------------------------------------------------------
-// createRequest（合并原 createPrepare + createApply）
+// 小e 环境：createRequest 改交浏览器页面填单（不写服务端）
 // ---------------------------------------------------------------------------
+/**
+ * 小e 环境下 `createRequest` 不写服务端，改为把「本次要填的字段值」渲染成 `<browsertool>` 块，
+ * 由宿主的浏览器页面把值带进新建页 —— 2026-10-15 用户裁定。
+ *
+ * 边界（用户口径，逐条对齐）：
+ * - **无条件直出**：`action=draft` / `submit` 都一样，既不请求 `saveData` / `flow/create` / `submit`，
+ *   也不做必填缺失判定（不返回 `NEEDS_INPUT`）；缺什么由浏览器页面里补。
+ * - 「字段重名 / 只读字段 / 值解析歧义」三类**连值都拼不出来**的结构性拦截**照旧生效**（在下面走
+ *   的就是与普通链路同一段代码），它们不是必填判定。
+ * - 句柄**不消费**：本分支在任何写请求之前返回，同一个 `context` 之后仍可正常重发。
+ * - `title` 取**工作流名称**；`src` 与两处 `routerProps_*` 的 `initialEntries` 用**工作流 id**；
+ *   `params.customParams` 取 `createRequest` **入参**经解析后的字段值（不含表单默认值、不含联动带出的值），
+ *   同段 `fieldAssignKeys` 列出这次要填的**全部字段 id**（`,` 连接）。
+ */
+const XIAOE_FILL_FORM_TOOL_ID = 'fill_form';
+/** 直出 `<browsertool>` 时写死的骨架（除 title / src / `routerProps_*` / `params.customParams` 外的全部内容）。 */
+const XIAOE_FILL_FORM_SDK_OPTIONS = {
+    compName: 'ui.CorsComponent',
+    routerType: 'MemoryRouter',
+    // 用户 2026-10-15 裁定：PC / 移动各一份 params，app 写死 `@weapp/workflow`。
+    // 2026-10-16 用户澄清：`@` 后面**没有**斜线，`weapp` 与 `workflow` 之间**一个**斜线
+    // ——聊天输入框会把这个值转义显示成 `@/weapp/workflow`，一律以本条为准。
+    // 路由组件分别取 `Comp.WffpRoute`（PC）/ `Comp.MWffpRoute`（移动，带 noMDialog）。
+    params_pc: {
+        app: '@weapp/workflow',
+        compName: 'Comp.WffpRoute',
+    },
+    params_mobile: {
+        app: '@weapp/workflow',
+        compName: 'Comp.MWffpRoute',
+        noMDialog: true,
+    },
+};
+/**
+ * `params.customParams` 字段值的两个分隔符 —— 口径来自用户 2026-10-15 给的实机截图：
+ * - **同一字段多值用 `,`**：`?<字段id>=0,1,2`（下拉复选框三选全中）
+ * - **明细多行用 `;`**：`?<明细字段id>=第一行;第二行;第三行`
+ * - 两者组合：`?<明细字段id>=0,1;2,0,2`（行内多值用 `,`、行与行之间用 `;`）
+ */
+const XIAOE_INITIAL_VALUES_MULTI_SEPARATOR = ',';
+const XIAOE_INITIAL_VALUES_ROW_SEPARATOR = ';';
+/** 单个标量 → URL 传参里的那一段文本。对象按「id 优先」取标识（附件取到的就是 fileid）。 */
+function xiaoEUrlParamScalar(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'object') {
+        const obj = value;
+        // 解析后的字段值是 `[{id, name}]` 形态（附件 / 选项 / 浏览按钮 / 人员范围都走这一份），
+        // `id` 就是可直接落库的标识：选项类是选项值（0/1/2）、附件类是 fileid、浏览按钮是记录 id。
+        // `name` / `content` 一律不用 —— 附件传文件名等于传一个指向不存在文件的坏 ID。
+        for (const key of ['id', 'optionId', 'fileId', 'fileid', 'fid', 'value']) {
+            const picked = obj[key];
+            if (picked === null || picked === undefined)
+                continue;
+            const text = String(picked).trim();
+            if (text)
+                return text;
+        }
+        return '';
+    }
+    return String(value).trim();
+}
+/** 单个字段的值 → URL 传参里的那一段文本（数组按「同字段多值」用 `,` 连接）。 */
+function xiaoEUrlParamValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => xiaoEUrlParamScalar(item))
+            .filter(Boolean)
+            .join(XIAOE_INITIAL_VALUES_MULTI_SEPARATOR);
+    }
+    return xiaoEUrlParamScalar(value);
+}
+/**
+ * `params.customParams` 里**字段值**那一份 = `{字段id: 值}`（用户裁定用**字段 id**，不用数据 key）；
+ * 同时回一份**字段 id 顺序表**，供同段 `fieldAssignKeys`（`,` 连接）用。
+ *
+ * 数据源是 `createRequest` **入参**经解析后的结果（`resolveEntryValues` 的 `preview`）——只含
+ * 模型本次真的传了的字段，不含表单默认值、不含联动带出的值。
+ *
+ * 明细字段（`preview` 里带 `dataIndex`）按**行号升序**取值、用 `;` 连接；主表字段就是它自己的值。
+ * 值为空（没解析出内容）的字段整个省略，不生成空参数。
+ */
+/**
+ * 小e 档交给浏览器页面的字段值：只留**可见且可编辑**的那些（2026-10-21 用户裁定）。
+ *
+ * 依据是 `computeLinkageVisibility` 用句柄里本地 `viewLinkages` 求出来的隐藏 / 禁用，再加上字段
+ * 自身的只读、禁填、初始隐藏（`display === false`）与布局隐藏（`hiddenCellFieldIds`）。
+ *
+ * 过滤的**只有值**，不改页面结构：这些字段在表单页里本来就填不进去（页面自己会拦），把值塞过去
+ * 只会让页面报错或让用户看到"填了但没生效"。
+ */
+function editablePreviewForXiaoE(preview, fields, visibility) {
+    const fieldById = new Map();
+    for (const field of toArray(fields)) {
+        const id = String(field?.id ?? '').trim();
+        if (id)
+            fieldById.set(id, field);
+    }
+    const kept = [];
+    for (const item of toArray(preview)) {
+        const fieldId = String(item?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        const field = fieldById.get(fieldId) || {};
+        if (field.readOnly || field.disableEdit || field.display === false)
+            continue;
+        if (visibility.hiddenFieldIds.has(fieldId))
+            continue;
+        const subFormId = String(field.subFormId ?? '').trim();
+        if (subFormId && visibility.hiddenSubforms.has(subFormId))
+            continue;
+        // 行键口径与 `computeLinkageVisibility` 完全一致（'main' 或 `<subFormId>:<dataIndex>`，
+        // 明细行没给行号时按第 1 行算）。
+        const hasRow = item?.dataIndex !== undefined && item?.dataIndex !== null;
+        const rowKey = rowKeyFor(subFormId, hasRow ? item.dataIndex : undefined);
+        if (visibility.rowHidden[rowKey]?.has(fieldId))
+            continue;
+        if (visibility.rowDisabled[rowKey]?.has(fieldId))
+            continue;
+        kept.push(item);
+    }
+    return kept;
+}
+function xiaoECustomParams(preview) {
+    const ordered = [];
+    const mainValues = new Map();
+    const detailValues = new Map();
+    for (const item of toArray(preview)) {
+        const fieldId = String(item?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        const text = xiaoEUrlParamValue(item?.value);
+        if (!text)
+            continue;
+        const isDetail = item?.dataIndex !== undefined && item?.dataIndex !== null;
+        if (!isDetail) {
+            if (!mainValues.has(fieldId) && !detailValues.has(fieldId))
+                ordered.push(fieldId);
+            mainValues.set(fieldId, text);
+            continue;
+        }
+        if (!detailValues.has(fieldId)) {
+            if (!mainValues.has(fieldId))
+                ordered.push(fieldId);
+            detailValues.set(fieldId, []);
+        }
+        const index = Number(item.dataIndex);
+        detailValues.get(fieldId).push({ index: Number.isFinite(index) ? index : 0, text });
+    }
+    const values = {};
+    for (const fieldId of ordered) {
+        const rows = detailValues.get(fieldId);
+        if (rows && rows.length) {
+            rows.sort((a, b) => a.index - b.index);
+            values[fieldId] = rows.map((row) => row.text).join(XIAOE_INITIAL_VALUES_ROW_SEPARATOR);
+            continue;
+        }
+        values[fieldId] = mainValues.get(fieldId) ?? '';
+    }
+    return { values, keys: ordered };
+}
+/**
+ * 渲染 `<browsertool>` 块（该块**整体**就是小e 环境下 `createRequest` 的 `finalMarkdown`）。
+ *
+ * 除 `title` / `src` / 两处 `routerProps_*` 的 `initialEntries` / `params.customParams` 外全部写死。
+ */
+function renderXiaoEFillFormMarkdown(params) {
+    const base = String(params.baseUrl ?? '').replace(/\/+$/u, '');
+    const workflowId = String(params.workflowId ?? '').trim();
+    const createPath = `/flowpage/create/${workflowId}`;
+    const payload = {
+        version: 1,
+        callId: 'call_001',
+        toolId: XIAOE_FILL_FORM_TOOL_ID,
+        arguments: {
+            type: 'e10',
+            title: String(params.title ?? ''),
+            src: `${base}/sp/workflow${createPath}?workflowId=${workflowId}&isCreate=1`,
+            sdkOptions: {
+                compName: XIAOE_FILL_FORM_SDK_OPTIONS.compName,
+                routerType: XIAOE_FILL_FORM_SDK_OPTIONS.routerType,
+                routerProps_pc: { initialEntries: [createPath] },
+                routerProps_mobile: { initialEntries: [createPath] },
+                params_pc: { ...XIAOE_FILL_FORM_SDK_OPTIONS.params_pc },
+                params_mobile: { ...XIAOE_FILL_FORM_SDK_OPTIONS.params_mobile },
+                params: {
+                    customParams: {
+                        // 字段 id → 值（要填写的字段及值），随后是这次要填的**全部字段 id**。
+                        ...params.customParams.values,
+                        fieldAssignKeys: params.customParams.keys.join(','),
+                    },
+                },
+            },
+        },
+    };
+    return `<browsertool>\n${JSON.stringify(payload, null, 2)}\n</browsertool>`;
+}
+/**
+ * 把命令耗时并回 `data` 顶层 —— `createRequest` 与 `createRequestDirect` **共用这一份口径**
+ * （2026-10-21 用户裁定：`createRequest` 也要给耗时，且与 `createRequestDirect` 一致）：
+ * - `durationMs` = 命令入口 → 结果产出；
+ * - `apiDurations` = 每个接口（并行批次合成一个 key，取墙钟、不叠加）；
+ * - `authMs` = 登录取凭据（首次会话解析）的墙钟 —— 这一段走 auth 层自己的 fetch、不经
+ *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账。
+ *
+ * `data` 不是普通对象时原样返回（被替换成字符串 / 数组的返回面一个字都不动）。
+ */
+function stampCommandTimings(envelope, timing) {
+    const data = envelope?.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return envelope;
+    const mutable = data;
+    mutable.durationMs = Date.now() - timing.startedAt;
+    mutable.apiDurations = summarizeApiSpans(timing.spans);
+    mutable.authMs = timing.authMs;
+    return envelope;
+}
+/**
+ * `createRequest` 的耗时外壳：建计时通道 + 量登录耗时 + 把三个耗时键并回结果。
+ *
+ * 参数明显不合法（`action` 不对 / 没 `context`）时**不先登录** —— 那两种情况内层会直接抛
+ * 参数错，为一个注定失败的调用白走一趟统一登录不值当；真正的报错措辞仍由内层给出。
+ */
+async function commandCreateRequest(args, env, options = {}) {
+    const startedAt = Date.now();
+    const spans = options.apiSpans ?? [];
+    // `createRequestDirect` 已经把 host 包过一层（它的片段数组覆盖到表单载入那一段）⇒ 这里不能再包，
+    // 否则每个请求会被记两遍（key 里会出现重名）。
+    const timedEnv = options.apiSpans ? env : { ...env, host: withApiTiming(env.host, spans) };
+    const action = String(args.action ?? '').trim();
+    let authMs = 0;
+    if ((action === 'draft' || action === 'submit') && String(args.context ?? '')) {
+        // 会话是惰性的：内层的 `verifyContextLease` 本来也会取一次，这里只是把它**提前并单独计时**，
+        // 拿到的仍是同一份缓存，不额外多发请求。
+        const authStartedAt = Date.now();
+        await timedEnv.host.getSession();
+        authMs = Date.now() - authStartedAt;
+    }
+    const envelope = await runCreateRequest(args, timedEnv, options);
+    return stampCommandTimings(envelope, { startedAt, spans, authMs });
+}
 /**
  * `workflow.createRequest` —— **一条命令**完成「字段解析 → 联动 → 必填校验 → 保存 → 发起」。
  *
@@ -3313,7 +4838,7 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
  * 返回**不消费**句柄，于是模型补齐字段后可以带**同一个 context** 重发，不必回头重跑 createForm；
  * 一旦消费，就只能按句柄状态分流（`ALREADY_APPLIED` / 结果不确定 / 并发占用）。
  */
-async function commandCreateRequest(args, env) {
+async function runCreateRequest(args, env, options = {}) {
     const action = String(args.action ?? '').trim();
     if (action !== 'draft' && action !== 'submit') {
         throw workflowValidationError('action_required', 'action 必填，且只能是 draft（仅存草稿）或 submit（提交审批）');
@@ -3346,13 +4871,35 @@ async function commandCreateRequest(args, env) {
     }
     const [details, valueAmbiguities, preview] = await resolveEntryValues(env, entries, context.layout.form_id);
     const merged = mergeDetails(context.defaults || [], details);
-    const linkageDetails = await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false);
+    /**
+     * 小e 环境（2026-10-16 用户裁定）：**字段联动与显示属性联动都不跑**。
+     *
+     * 这一档真正的填单动作由宿主浏览器页面完成（见下方 `BROWSER_FILL` 分支），本命令只负责把
+     * 「本次要填的字段值」交给页面：联动**带出的值**、以及联动求出来的隐藏 / 条件必填 / 禁填，
+     * 到了表单页里都会由页面自己重算一遍。在这里跑一是白费一趟 `fdLinkage` 请求，二是这些结果
+     * 全都进不了本档的输出（`customParams` 取的是 `preview`，即入参解析后的值）。
+     *
+     * ⚠️ 与同一次裁定里 `createForm` 的差别：那边是「不跑字段联动、**显示属性联动照跑**」
+     * （`buildCreateFormData`，那边的联动结果要用来算字段的必填 / 可编辑清单）；这里两者都不跑 ——
+     * 本档既不做必填判定、也不发写请求。非小e 环境行为不变。
+     */
+    const isXiaoE = hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
+    const linkageDetails = isXiaoE
+        ? []
+        : await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false, context.defaults || []);
     // 明细默认值无行号，而判缺失/写载荷都按行号索引 ⇒ 按用户已建行补齐缺口（V12.1.35，
     // 详见 fillDetailDefaultsByRow 注释）。放在联动之后合并，联动带出的值仍然优先。
     const merged2 = fillDetailDefaultsByRow(mergeLinkageDetails(merged, linkageDetails), context.defaults || [], userDetailRows(entries));
     const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
     const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
-    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = computeLinkageVisibility(context.viewLinkages, entries, context.defaults || [], linkageDetails, context.systemFieldValues, fields);
+    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = isXiaoE
+        ? (options.xiaoEViewLinkageFilter
+            // 2026-10-21 用户裁定（`createRequestDirect` 这一档）：小e 档**照跑显示属性联动**，只是不跑字段联动
+            // —— 它要据此把页面本来就填不进去的字段（隐藏 / 禁用）从要填的值里剔掉。
+            // 第三参传 `[]`（本次没有联动带出的值）时，求值只用表单默认值 + 本次入参 + 系统字段值。
+            ? computeLinkageVisibility(context.viewLinkages, entries, context.defaults || [], [], context.systemFieldValues, fields)
+            : emptyLinkageVisibility())
+        : computeLinkageVisibility(context.viewLinkages, entries, context.defaults || [], linkageDetails, context.systemFieldValues, fields);
     const initialHidden = new Set(fields.filter((f) => f.display === false).map((f) => String(f.id ?? '')));
     if (initialHidden.size) {
         const mh = new Set(rowHidden.main || []);
@@ -3390,25 +4937,52 @@ async function commandCreateRequest(args, env) {
     }
     const missingAll = [...missing, ...systemMissing];
     /**
-     * 历史参考值（V12.1.77）：取数已在 `createForm` 做完，这里**只从句柄里的缓存筛**，不再联网。
+     * 历史参考值在 `createRequest` 一侧**不再返回**（V12.1.102 撤出；V12.1.77 曾在这里从句柄缓存
+     * 筛"这次新出现的必填字段"的历史值一并给回）。
+     *
+     * 撤出理由（2026-10-13 真机复核）：文档口径早已明令 `NEEDS_INPUT` / `NEEDS_CONFIRMATION` 时
+     * `historyRequestData` **一律不看、不用**（必填缺失直接一次问齐用户，不做任何值推断）——这份数据
+     * 于是只剩副作用：既白占返回体积（真机 3,649 B 里占 2,173 B＝60%，且 5 条记录还是同一组值的
+     * 重复），又逼模型多烧一轮说服自己"不要看"，返回值与规则自相矛盾。
      *
-     * 只筛「**这次新出现**的必填字段」——即 `createForm` 当时还没被判成必填、模型因此没见过的那些
-     * （绝大多数是联动命中后才变成必填的字段）。`createForm` 已经给过历史值的字段不再重复返回：
-     * 那些值模型本来就拿到了，重复给只是白占上下文。
+     * 历史参考值的唯一入口回到 `createForm`（那边给的仍是"本表单静态必填字段"的参考值）。
+     *
+     * 2026-10-13 晚补（用户口径）：原始历史**仍然不返回**给模型，但命令**内部**继续用它——
+     * 为缺失的必填字段算一条「历史取值一致」的**推荐值**渲染进 `finalMarkdown`（见
+     * `historyRecommendation`）。这样用户能一句话确认，而"一致性判断"这件容易让模型绕圈的事
+     * 全部留在命令侧，模型拿到的仍是一份可直接粘贴的文本。
+     */
+    /**
+     * 「已填内容」的两组行（2026-10-14 用户口径）：**系统字段（流程标题等）在前、业务字段按表单
+     * 布局顺序随后**，两份渲染档（必填缺失 / 已落地）共用同一份口径。值取自 `merged2`
+     * （表单默认值 + 本次入参 + 联动带出的值），也就是"用户在表单上看到的那一份"。
      *
-     * `createForm` 缓存是"本表单全部字段"的宽结果（`allFormFields`），所以新字段也能命中；
-     * 缓存取不到 / 一个值都没命中 ⇒ `null`（不塞空数组）。句柄不是本机签发、或会话跨版本升级时
-     * 缓存可能缺失，此时退化为 `null`——纯辅助信息，不阻断任何流程。
+     * 真机现场：用户看到的「已填内容」只有模型显式传的两项，而表单上明明还有一批**已填状态**的
+     * 字段（表单默认值、流程标题）——用户无法据此确认"这张单到底填成什么样了"。
      */
-    const knownRequiredFieldIds = new Set(toArray(context.historyRequiredFieldIds).map((id) => String(id ?? '').trim()).filter(Boolean));
-    const newMissingFieldIds = new Set();
-    for (const item of missingAll) {
-        const fieldId = String(item?.id ?? '').trim();
-        if (!fieldId || item?.systemField || knownRequiredFieldIds.has(fieldId))
+    const mainValueById = new Map();
+    for (const detail of merged2) {
+        if (!detail || typeof detail !== 'object')
             continue;
-        newMissingFieldIds.add(fieldId);
-    }
-    const historyRequestData = filterHistoryRequestData(context.historyCache, newMissingFieldIds);
+        const subFormId = String((detail.subForm && detail.subForm.id) ?? detail.subFormId ?? '').trim();
+        if (subFormId)
+            continue;
+        const fieldId = String((detail.formField && detail.formField.id) ?? '').trim();
+        if (fieldId)
+            mainValueById.set(fieldId, detail);
+    }
+    const filledFieldRows = mainFilledRows(fields, mainValueById, 
+    // `rowHidden.main` 已并入布局隐藏（见上面 `initialHidden` 的合流），再补 `hiddenCellFieldIds`。
+    new Set([...(rowHidden.main || []), ...hiddenFieldIds]), new Set(rowDisabled.main || []), compsFieldIds);
+    const filledTitleRows = (title) => systemFilledRows({
+        title,
+        requestLevel: requestLevelValue,
+        secLevel: secLevelValue,
+        permissions: sysPermissions,
+        // 老句柄可能没有这两个选项清单（键名也随版本变过一次），取不到就退化成"不列系统字段"。
+        levelOptions: (context.systemFields && (context.systemFields.level_options || context.systemFields.levelOptions)) || [],
+        secLevelOptions: (context.systemFields && (context.systemFields.sec_level_options || context.systemFields.secLevelOptions)) || [],
+    });
     if (valueAmbiguities.length) {
         return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_CONFIRMATION',
@@ -3420,20 +4994,84 @@ async function commandCreateRequest(args, env) {
             resolvedValues: preview,
             ambiguities: valueAmbiguities,
             missingFields: missingAll,
-            historyRequestData,
             linkageResult,
             ...folderPayload,
         });
     }
+    /**
+     * 小e 环境（2026-10-15 用户裁定）：**一个写请求都不发**，直接把本次要填的字段值渲染成
+     * `<browsertool>` 交给宿主的浏览器页面 —— 因此这里**不判必填缺失**（不返回 `NEEDS_INPUT`），
+     * `draft` / `submit` 走的都是这一条。
+     *
+     * 放置位置：在所有"连值都拼不出来"的结构性拦截（字段重名 / 只读字段 / 值解析歧义，都在本行之上）
+     * **之后**、必填缺失分支与写入路径（`verifyContextLease(token, …, true)` 消费句柄、`saveData`、
+     * `flow/create`、`submit`）**之前**。于是：句柄不被消费、一个写请求都不发，同一个 `context` 之后
+     * 仍可正常重发。
+     *
+     * 渲染档（2026-10-15 用户裁定）：`finalMarkdown` **整体就是一段 `<browsertool>` 标签块**；本轮回复正文
+     * = 这段内容本身（从 `<browsertool>` 到 `</browsertool>`），原样输出、**不要包在代码块里**。
+     *
+     * **stdout 形态**（2026-10-21 用户裁定，**改口径**）：这一档同样**走 JSON 信封**，标签块放在
+     * `data.finalMarkdown` 里 —— 与 `createRequestDirect` 统一，模型侧只有一条读法；`durationMs` /
+     * `apiDurations` / `authMs` 三个耗时键也因此在这一档可见。原来的「stdout 直接就是标签块、不套
+     * 信封」已作废（`shortcuts/workflow/index.ts` 的直出通道随之删除）。
+     * 所以下面的 `message` 要明确告诉模型：从 `data.finalMarkdown` 取内容、原样作为本轮回复正文。
+     *
+     * 判据：桌面客户端可由 Agent 根据宿主明确上下文传入全局参数 `--runtime-agent xiaoe`；
+     * 传入环境中存在任意 `XIAOE_*` 变量时也直接判定为小e环境。
+     * 历史会话和本地文件本身不参与宿主身份判断。
+     * 本处复用上面算好的 `isXiaoE`（同一判据，只求值一次）。
+     *
+     * 本档**不跑字段联动、也不跑显示属性联动**（2026-10-16 用户裁定，见上方 `isXiaoE` 的注释）：
+     * 所以这里既没有「字段联动带出」的提示，`hiddenSubforms` / `rowExtraRequired` / `rowDisabled`
+     * 也都是空集 —— 该由浏览器页面在表单里自己算。
+     */
+    if (isXiaoE) {
+        // `src` 要的是绝对地址：句柄里带走的那份 baseUrl 为准（与句柄同源，避免"换了域名后旧句柄拼出别的站"），
+        // 旧版本句柄可能没带 ⇒ 回落到当前会话的 baseUrl。
+        const xiaoEBaseUrl = String(context.baseUrl ?? '') || (await getSessionContext(env)).baseUrl;
+        // 交给页面的值：`createRequestDirect` 这一档先按显示属性联动过滤掉不可编辑字段（见上方 options 注释），
+        // 其余入口（`createRequest`）原样传 `preview`。
+        const fillPreview = options.xiaoEViewLinkageFilter
+            ? editablePreviewForXiaoE(preview, fields, { hiddenSubforms, rowHidden, rowDisabled, hiddenFieldIds })
+            : preview;
+        return workflowSuccess('workflow.createRequest', {
+            status: 'BROWSER_FILL',
+            contextId: token,
+            // 本档只有一种输出形态（JSON 信封），指引也就只有一条：从 `data.finalMarkdown` 取内容。
+            message: '当前是小e环境：本次不向服务端写入，改由浏览器页面完成填单。本档输出的是 JSON 信封（额外带 durationMs / apiDurations / authMs 耗时），`data.finalMarkdown` 就是那段 <browsertool> 标签块（其中的换行在 JSON 里以 \\n 转义）。把 `data.finalMarkdown` 的内容原样作为本轮回复正文：从 <browsertool> 到 </browsertool>、换行还原成真实换行，不要包在代码块里、不要加任何前后说明；JSON 信封本身不要回给用户。',
+            workflow: context.workflow,
+            finalMarkdown: renderXiaoEFillFormMarkdown({
+                baseUrl: xiaoEBaseUrl,
+                title: String(context.workflow?.name ?? ''),
+                workflowId: String(context.workflow?.id ?? context.runtime?.workflow_id ?? ''),
+                customParams: xiaoECustomParams(fillPreview),
+            }),
+        });
+    }
     if (action === 'submit' && missingAll.length) {
-        // submit 且有必填缺失：**不调用创建接口**，把缺失项一次交回给模型/用户
+        // submit 且有必填缺失：**不调用创建接口**，把缺失项一次交回给模型/用户。
+        //
+        // 同时给一份可直接原样粘贴的渲染档（V12.1.102）：结论 + 主表「已填内容」两列表（含流程标题与
+        // 表单默认值，2026-10-14 起）+ 明细 Excel 列 + 待补必填项清单。模型不必自己拼这些表格，也不必再
+        // 遍历 `resolvedValues` 拼待补清单；因此这里**不再返回** `resolvedValues`（渲染素材只在命令内部用）。
+        const pendingRequestName = String(args.requestName ?? sysDefaults.requestName ?? context.runtime.default_request_name ?? '').trim();
+        // ★ 2026-10-20 用户裁定：**有 `finalMarkdown` 的状态不再返回 `message`**。
+        // 这条路一定有渲染档（`renderCreatePendingMarkdown` 至少输出结论句 + 待补清单），
+        // 而 `message` 说的是同一件事、口气还是"对模型下指令"（"带同一 context 重发 action=submit"），
+        // 模型看到就会在 `finalMarkdown` 之外多输出一段、顺带把内部机制漏给用户。
         return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_INPUT',
             contextId: token,
-            message: '缺少必填字段，本次未发起流程。请把下面这些字段一次问齐后，带同一 context 重发 action=submit。',
-            resolvedValues: preview,
             missingFields: missingAll,
-            historyRequestData,
+            finalMarkdown: renderCreatePendingMarkdown({ missingFields: missingAll, linkageResult }, 
+            // 标题行按"当前还没填到标题"的口径取（可能为空 ⇒ 不出现该行），与落地档的 `requestName` 兜底分开。
+            [...filledTitleRows(pendingRequestName), ...filledFieldRows], buildPreviewDetails(preview), 
+            // 历史推荐值的数据源：`createForm` 随句柄留下的**宽缓存**（本表单全部字段）。
+            // 只用来算"这个缺失字段历史取值是否一致"，**不返回**给模型——一致性判断不外包给模型。
+            context.historyCache, 
+            // 缺项类型提示用：缺项是发票 / 附件类时把"怎么给"写在渲染档里（见函数内注释）。
+            fields),
             linkageResult,
             ...folderPayload,
         });
@@ -3637,8 +5275,206 @@ async function commandCreateRequest(args, env) {
                     : '。');
         }
     }
+    // 渲染档：流程**已落地**时给一份可直接原样粘贴的最终回复文本（与查询侧 `finalMarkdown` 同口径）。
+    // `NEEDS_INPUT` 的那份在上面分支里就已挂上（同口径、只换结论句与末段）；`NEEDS_CONFIRMATION` 不给。
+    // 标题行用**本次真正落库的** `requestName`（与 `prepared.requestName` 同源），不再是"可能为空"的口径。
+    if (['CREATED', 'CREATED_SUBMITTED', 'CREATED_SUBMIT_FAILED'].includes(String(result.status))) {
+        result.finalMarkdown = renderCreateResultMarkdown(result, [...filledTitleRows(requestName), ...filledFieldRows]);
+        // ★ 渲染档的**结论句就是 `message`**（`renderCreateResultMarkdown` 第一行取的它），所以只能在
+        // 渲染之后再摘键——不是不用它，是**不单独返回它**：返回面里 `message` 与 `finalMarkdown` 说的
+        // 是同一句话，模型只会挑一个输出，留着就是给自己制造"两个声音"（2026-10-20 用户裁定）。
+        delete result.message;
+    }
     return workflowSuccess('workflow.createRequest', result);
 }
+// ---------------------------------------------------------------------------
+// 接口耗时（`workflow.createRequestDirect`）
+// ---------------------------------------------------------------------------
+/**
+ * 接口**简称**：`path` → 模型看得懂的短名。
+ *
+ * 只登记这条命令真会打到的接口（解析工作流 / 载入表单 / 联动 / 写库 / 校验 / 浏览按钮）；
+ * 没登记的按路径最后一段兜底，不会因为漏登记就把计时丢掉。
+ */
+const API_SHORT_NAMES = {
+    [FORM_ENDPOINTS.workflowCreateList]: 'newFlowList',
+    [FORM_ENDPOINTS.loadBase]: 'loadBase',
+    [FORM_ENDPOINTS.loadFrame]: 'loadFrame',
+    [FORM_ENDPOINTS.loadMinor]: 'loadMinor',
+    [FORM_ENDPOINTS.formLayout]: 'formLayout',
+    [FORM_ENDPOINTS.tenantSetting]: 'tenantSetting',
+    [FORM_ENDPOINTS.fdLinkage]: 'fdLinkage',
+    [FORM_ENDPOINTS.save]: 'saveFormData',
+    [FORM_ENDPOINTS.create]: 'flowCreate',
+    [FORM_ENDPOINTS.flowSubmit]: 'flowSubmit',
+    [FORM_ENDPOINTS.signInputInfo]: 'signInputInfo',
+    [FORM_ENDPOINTS.submit]: 'submitRequest',
+    [FORM_ENDPOINTS.nameToId]: 'relateName2Id',
+    [FORM_ENDPOINTS.verifyNodeFieldByList]: 'verifyNodeField',
+    [FORM_ENDPOINTS.conformanceSet]: 'conformanceSet',
+    [FORM_ENDPOINTS.verificationRequestData]: 'verificationRequestData',
+    [FORM_ENDPOINTS.verificationConditionRule]: 'verificationConditionRule',
+    [WORKFLOW_ENDPOINTS.MINE_TREE]: 'mineTree',
+    [WORKFLOW_ENDPOINTS.MEMORY_PROMPT]: 'memoryPrompt',
+    [WORKFLOW_ENDPOINTS.WORKFLOW_PATH_BROWSER]: 'workflowPathBrowser',
+    [WORKFLOW_ENDPOINTS.RESOURCE_BROWSER]: 'resourceBrowser',
+    [WORKFLOW_ENDPOINTS.HRM_RESOURCE_BROWSER]: 'hrmResourceBrowser',
+    [WORKFLOW_ENDPOINTS.DEPT_BROWSER]: 'deptBrowser',
+    [WORKFLOW_ENDPOINTS.SUBCOMPANY_BROWSER]: 'subcompanyBrowser',
+    [WORKFLOW_ENDPOINTS.GROUP_BROWSER]: 'groupBrowser',
+    [WORKFLOW_ENDPOINTS.ROLE_BROWSER]: 'roleBrowser',
+    [WORKFLOW_ENDPOINTS.POSITION_BROWSER]: 'positionBrowser',
+    [WORKFLOW_ENDPOINTS.NODE_BROWSER]: 'nodeBrowser',
+    [WORKFLOW_ENDPOINTS.FIELD_OPTION_BROWSER]: 'fieldOptionBrowser',
+    [WORKFLOW_ENDPOINTS.REQUEST_DETAIL]: 'getWorkflowRequest',
+    // 智能填参（非 workflow 前缀，靠 `aiappuniquekey` 头定位智能体应用，见 chatscene.ts）
+    '/api/ai/application/chat/chatScene': 'chatScene',
+};
+function apiShortName(path) {
+    const text = String(path ?? '');
+    const known = API_SHORT_NAMES[text];
+    if (known)
+        return known;
+    const segments = text.split('/').filter(Boolean);
+    return segments.length ? segments[segments.length - 1] : text || 'unknown';
+}
+/**
+ * 给 host 套一层**逐接口计时**（只包请求，不改返回、不吞异常）。
+ *
+ * `finally` 里落片段：请求失败（超时 / 业务错误 / 抛错）同样要记 —— 恰恰是这类请求最需要看到耗时。
+ */
+function withApiTiming(host, spans) {
+    const record = async (path, run) => {
+        const start = Date.now();
+        try {
+            return await run();
+        }
+        finally {
+            spans.push({ name: apiShortName(path), start, end: Date.now() });
+        }
+    };
+    return {
+        ...host,
+        workflowRequest: (request) => record(request?.path, () => host.workflowRequest(request)),
+        workflowBinaryRequest: (request) => record(request?.path, () => host.workflowBinaryRequest(request)),
+    };
+}
+/**
+ * 把逐次请求的片段收成「一条命令里每个接口花了多久」。
+ *
+ * 口径（2026-10-21 用户裁定）：
+ * - **并行**（时间区间重叠）的接口合成**一个 key**：各简称用 `_` 拼起来（多个时按字母序，保证同一批
+ *   接口每次输出同一个 key），**值取这一批的墙钟耗时**（最早开始 → 最晚结束），**不是**把批内每个
+ *   接口的耗时相加；
+ * - 串行接口各自一个 key，值就是它自己的耗时；
+ * - 同一个 key 出现多次（同一接口被调了两轮）按累加计 —— 那确实是两笔独立开销。
+ *
+ * 重叠判定用「区间扫描」而不是推断代码里的并发结构：只要两个请求在时间上真重叠就算一批，
+ * 批量接口内部再起并发也照样能反映出来。
+ */
+function summarizeApiSpans(spans) {
+    const sorted = [...spans].sort((a, b) => (a.start - b.start) || (a.end - b.end));
+    const groups = [];
+    let current = [];
+    let reach = Number.NEGATIVE_INFINITY;
+    for (const span of sorted) {
+        // 端点相接（`start === reach`）按串行算：前一个已经返回，后一个才开始。
+        if (current.length && span.start < reach) {
+            current.push(span);
+            reach = Math.max(reach, span.end);
+        }
+        else {
+            if (current.length)
+                groups.push(current);
+            current = [span];
+            reach = span.end;
+        }
+    }
+    if (current.length)
+        groups.push(current);
+    const out = {};
+    for (const group of groups) {
+        const names = group.map((item) => item.name);
+        const key = names.length === 1 ? names[0] : [...names].sort().join('_');
+        const cost = Math.max(0, Math.round(Math.max(...group.map((item) => item.end)) - Math.min(...group.map((item) => item.start))));
+        out[key] = (out[key] ?? 0) + cost;
+    }
+    return out;
+}
+/**
+ * `workflow.createRequestDirect` —— **临时命令**：把「载入表单 + 智能填参」和「发起」串成一步。
+ *
+ * 等价于「先跑 `createForm`（带 `userQuestion`），再把它的 `contextId` 与 `data` 原样交给
+ * `createRequest`」，区别只在一次进程内完成、不给模型中间态。
+ *
+ * ## 四条口径
+ * 1. **取数阶段复用** `prepareCreateFormPayload`（`createForm` 的同一段代码），所以澄清 / 表单不可发起
+ *    这类错误**原样上抛**，新命令一条都不会吞，也不会在澄清时硬着头皮发写请求。
+ * 2. 智能填参走通 ⇒ 用它算出的 `data`；**没走通（超时 / 返回体不合法 / 未传 userQuestion）⇒ 按
+ *    `data` 为空继续** —— 交给 `createRequest` 自己的必填校验去判定（`submit` 缺必填不写库、
+ *    `draft` 直接建草稿），与"模型没填任何字段就调 createRequest"完全等价。
+ * 3. **小e 档**：不跑字段联动（页面自己会重算），但**跑显示属性联动并把不可编辑字段过滤掉**
+ *    （`xiaoEViewLinkageFilter`），交出去的值只含页面真能填的字段。
+ * 4. 最终返回 **`createRequest` 的结果**（`data` 与各状态语义完全一致，`action` 仍是
+ *    `workflow.createRequest`），只额外挂三个耗时键（见下）。JSON 信封的 `operation` 是
+ *    `workflow.createRequestDirect`（由命令层盖，见 `successEnvelope`）。
+ *
+ * ## 小e 档也走 JSON（2026-10-21 用户裁定，已推广到原命令）
+ * 原命令在小e 下曾直出 `<browsertool>`，那条路会把耗时藏掉。现在**两条命令统一走 JSON 信封**：
+ * `data.finalMarkdown` 仍是同一段标签块，`data.durationMs` / `data.apiDurations` / `data.authMs`
+ * 一并可见；`message` 告知模型从 `finalMarkdown` 取内容原样回复。
+ *
+ * ## 耗时
+ * - `data.durationMs` = 命令总耗时；
+ * - `data.apiDurations` = 每个接口（并行批次合并）的耗时；
+ * - `data.authMs` = 登录取凭据（首次会话解析）的耗时 —— 这段走 auth 层自己的 fetch，不经
+ *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账
+ *   （`durationMs` ≈ `apiDurations` 合计 + `authMs` + 本地解析/渲染的零头）。
+ * 三者都只在 `data` 是普通对象时挂；本命令与 `createRequest` 用的是**同一个** `stampCommandTimings`，
+ * 差别只在时间区间（这里从命令入口起算、覆盖表单载入那一段）。
+ */
+async function commandCreateRequestDirect(args, env) {
+    const startedAt = Date.now();
+    const action = String(args.action ?? '').trim();
+    // 先校验 action 再取数：参数错就没必要白跑一趟表单载入（那是最贵的一段）。
+    if (action !== 'draft' && action !== 'submit') {
+        throw workflowValidationError('action_required', 'action 必填，且只能是 draft（仅存草稿）或 submit（提交审批）');
+    }
+    // 计时从**命令入口**开始算（含会话解析、工作流消歧、表单载入、智能填参、写库、校验）。
+    const spans = [];
+    const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    const { payload, fill, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    const contextId = String(payload.contextId ?? '');
+    if (!contextId) {
+        // `prepareCreateFormPayload` 正常返回时 contextId 必然存在；这里只是不带着空句柄去调写接口。
+        throw workflowValidationError('context_missing', '表单载入未产出可用句柄，本次未发起任何写入，请重试');
+    }
+    // ★ 智能体没给出可用 data ⇒ `{}`（不是老口径的 historyRequestData：本命令不做二次推断，
+    // 有值就用、没有就交给必填校验）。
+    const data = (fill.applied && fill.data && typeof fill.data === 'object')
+        ? fill.data
+        : {};
+    const systemData = fill.systemData ?? {};
+    const requestName = String(payload.requestName ?? '').trim();
+    const requestLevel = String(systemData.requestLevel ?? '').trim();
+    const secLevel = String(systemData.secLevel ?? '').trim();
+    const remark = String(systemData.remark ?? '').trim();
+    const envelope = await commandCreateRequest({
+        context: contextId,
+        data,
+        action,
+        // ★ 空串一律**不传键**：`createRequest` 的兜底链是 `args.x ?? sysDefaults.x ?? 句柄里的默认值`，
+        // 而 `??` 挡不住空串 —— 传 `''` 会把后面的默认值全部短路掉（`request_name 不能为空` 就是这么来的）。
+        ...(requestName ? { requestName } : {}),
+        ...(requestLevel ? { requestLevel } : {}),
+        ...(secLevel ? { secLevel } : {}),
+        ...(remark ? { remark } : {}),
+        verificationConfirmed: args.verificationConfirmed,
+    }, timedEnv, { xiaoEViewLinkageFilter: true, apiSpans: spans });
+    // 把耗时并回结果：与 `createRequest` 同一个函数、同一个口径，只是时间区间是整条命令
+    // （含会话解析、工作流消歧、表单载入、智能填参、写库、校验）。
+    return stampCommandTimings(envelope, { startedAt, spans, authMs });
+}
 function formatRemark(value) {
     const text = String(value ?? '').trim();
     if (!text)
@@ -3757,10 +5593,17 @@ function buildCreateBody(context, prepared, saved, src) {
  *   - 多带 `operResultType`/`userSpecifiedNodeId`/`needAutoOpen`/`autoMaxDisplay`/`testParam`/
  *     `seconedSubmit`（字段名本来就少一个 n，照抄不改）。
  */
-function buildSubmitBody(context, prepared, view) {
+function buildSubmitBody(context, prepared, view, 
+/**
+ * 已经按默认样式包好的签字意见（见 `sign-input.ts`）。
+ *
+ * 不传则退回 `formatRemark` 的老形态 —— 只有"确实要提交、且内容非空"的那一档才会传，
+ * 空意见与降级路径仍是 `_weaverMte_`，与历史完全一致。
+ */
+wrappedRemark) {
     const runtime = context.runtime;
     const requestId = String(runtime.request_id ?? '');
-    const remark = formatRemark(prepared.remark);
+    const remark = wrappedRemark ?? formatRemark(prepared.remark);
     return {
         operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE',
         userSpecifiedNodeId: '0',
@@ -4008,13 +5851,18 @@ async function loadCreateSubmitContext(env, context, requestLevel) {
  * 连接中断同样按"提交结果不确定"如实回报；**认证错误照规则原样抛**，不降级成数据结论。
  */
 async function submitCreatedRequest(env, context, prepared, view) {
+    // 提交前先按租户配置把签字意见包成带默认字体/字号的形态（发起流程 ⇒ `isCreate:1` + `workflowId`）。
+    // 取不到样式时 `resolveSignRemark` 内部已退回老形态，不会阻断提交。
+    const signRemark = await resolveSignRemark(env, prepared.remark, {
+        workflowId: String(context.workflow?.id ?? ''),
+    });
     let response;
     try {
         response = await env.host.workflowRequest({
             method: 'POST',
             path: FORM_ENDPOINTS.flowSubmit,
             query: { requestId: String(context.runtime.request_id ?? '') },
-            body: buildSubmitBody(context, prepared, view),
+            body: buildSubmitBody(context, prepared, view, signRemark),
             operation: 'workflow.createRequest',
         });
     }
@@ -4505,7 +6353,7 @@ async function commandEditPrepare(args, env) {
         });
     }
     const merged = mergeDetails(context.currentDetails || [], details);
-    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true);
+    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true, context.currentDetails || []);
     const merged2 = mergeLinkageDetails(merged, linkageDetails);
     const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
     const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
@@ -4679,7 +6527,7 @@ const workflowCreateForm = {
     resource: 'workflow',
     method: 'createForm',
     action: 'workflow.createForm',
-    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好 + 本表单必填字段的历史参考值（不落业务数据）',
+    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好。传了 userQuestion 时额外调智能体把意图算成 data 参数（此时不返回 historyRequestData / systemFields）',
     capability: 'create',
     risk: 'read',
     requiresConfirmation: false,
@@ -4687,9 +6535,16 @@ const workflowCreateForm = {
         workflow: {
             type: 'array',
             items: { type: 'string' },
-            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用英文逗号分隔，如 "报销,报销流程")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；0 命中或多命中且无全名精确匹配时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
+            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用中英文逗号分隔，如 "请假,请假申请")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；未能唯一确定目标时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
         },
         relatesTo: { type: 'string', description: '可选关联对象 id（仅透传，不影响表单初始化）' },
+        userQuestion: {
+            type: 'string',
+            description: '用户的填单意图（用一句话概括，可以是多轮对话汇总后的最终需求）。'
+                + '**传了才启用智能填参**：命令会在返回前把它连同字段清单交给智能体，换回已填好的 data 参数'
+                + '（此时不再返回 historyRequestData / systemFields）。'
+                + '不传 = 关闭这条链路，按原口径返回 historyRequestData 等参考值（老调用方零改动）',
+        },
     }, { required: ['workflow'] }),
     handler: (args, env) => commandCreateForm(args, env),
 };
@@ -4718,6 +6573,34 @@ const workflowCreateRequest = {
     }, { required: ['context', 'data', 'action'] }),
     handler: (args, env) => commandCreateRequest(args, env),
 };
+const workflowCreateRequestDirect = {
+    name: 'workflow.createRequestDirect',
+    resource: 'workflow',
+    method: 'createRequestDirect',
+    action: 'workflow.createRequestDirect',
+    summary: '一步发起（直接给 workflow，不必先调 createForm 取句柄；仍按 requiresConfirmation 先取得用户确认）：先按 createForm 解析工作流并载入表单、把 userQuestion 交给智能体算成 data，然后直接接着执行 createRequest（保存 → 创建 → 可选提交）；智能体没给出可用 data 时按 data 为空继续。小e 环境不跑字段联动但照跑显示属性联动、只交可编辑字段。返回结果与 createRequest 一致，另带 durationMs（总耗时）、apiDurations（每接口耗时）与 authMs（登录取凭据耗时）',
+    capability: 'create',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        workflow: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '工作流条件：支持 "名称(ID)"、名称（可传多个，用英文逗号分隔）、纯数字 ID；语义与 createForm 的 workflow 完全一致（含澄清规则）',
+        },
+        userQuestion: {
+            type: 'string',
+            description: '用户的填单意图（一句话概括，可多轮汇总）。命令会把它交给智能体算出要填的字段值后直接发起；为空或智能体没给出可用结果时，按"一个字段都没填"继续发起',
+        },
+        action: {
+            type: 'string',
+            enum: ['draft', 'submit'],
+            description: 'draft=仅保存草稿；submit=提交审批（必填缺失时不写库、一次性回报缺失项）',
+        },
+        verificationConfirmed: { type: 'boolean', description: '节点字段校验需用户确认时显式确认继续提交' },
+    }, { required: ['workflow', 'userQuestion', 'action'] }),
+    handler: (args, env) => commandCreateRequestDirect(args, env),
+};
 const workflowEditLoad = {
     name: 'workflow.editLoad',
     resource: 'workflow',
@@ -4767,6 +6650,7 @@ const workflowEditApply = {
 export const workflowFormOperations = [
     workflowCreateForm,
     workflowCreateRequest,
+    workflowCreateRequestDirect,
     workflowEditLoad,
     workflowEditPrepare,
     workflowEditApply,