weaver-work-cli 0.1.24 → 0.1.25

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

@@ -17,12 +17,14 @@
  */
 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 { 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 } from './read.js';
+import { hasXiaoEEnv } from '../../../internal/e10/auth/xiaoe.js';
 // ---------------------------------------------------------------------------
 // 常量（与 Python 源逐条对齐）
 // ---------------------------------------------------------------------------
@@ -58,10 +60,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 +85,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。
  *
- * 用户明确要求：① 超线**只回提示**，不再回任何精简属性 —— 否则模型会先思考一段再决定读不读；
- * ② 提示里**直接给出可执行的读命令**（工具 + `file_path` + 精确 `limit`），避免模型自己把 `limit`
- * 给小了、于是分段读好几次；③ **除这两行外一个字都不要**（原话："其余内容都去掉"）。
+ * ★ 量的对象是**最终打出去的那份文本**（`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 不是必经步骤**，
+ * 只在需要运行时 / 系统字段这类细节时才用；首句先说清"不必读取"，否则模型仍会照抄去读（那正是要省的）。
+ *
+ * 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 +717,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 +983,240 @@ 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;
+}
 function parseLayoutMeta(layoutData) {
     const hiddenCellIds = new Set();
     const compsFieldIds = new Set();
@@ -918,6 +1277,15 @@ function parseLayoutMeta(layoutData) {
                     layoutSubformIds.add(sid);
             }
         }
+        // 行隐藏 / 单元格隐藏 / 明细表隐藏列 / 多内容单元格隐藏**同义**（都是"用户在表单上看不到"），
+        // 并成一份 `hiddenCellIds`：下游 `visibleFields`/`initialValue`/`missingRequiredFields`/「已填内容」
+        // /联动提示全部只认这一份，且随句柄以 `hiddenCellFieldIds` 传给 `createRequest`，两边口径天然一致。
+        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 +1308,8 @@ function applyViewRelateHidden(layoutSubformIds, viewRelateConfig) {
  * `viewRelateConfig` 长度为 0"并非服务端没配置，而是 `getFormLayout` 请求多带了顶层 `permissionId`
  * （未启用节点权限的表单会因此拿不到字段级属性；见 `buildLayoutRequest`）。该请求口径修正后，
  * 本告警只在服务端**确实**不下发字段属性时才出现（如启用节点权限的表单）。
- * 真正未下发时：`requiredFields` 只剩系统字段、`subFormRequired` 恒为 `{}`，**不代表表单没有必填项**。
+ * 真正未下发时：服务端没有字段级的 required / disableEdit / display 配置，`fields` 里的只读 / 禁止编辑
+ * 判定与「标记未下发」都因此失真，**不代表表单没有必填项**。
  *
  * V12.1.27 纠正（此前措辞有硬伤）：原文案把 `missingFields` 也写成"为空不代表没有必填/无法据此校验业务必填"，
  * 与事实相反——本租户的业务必填多为**条件必填**（`viewLinkages` 的 `required` 规则），
@@ -950,13 +1319,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,10 +1339,10 @@ 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 一次性向用户问齐。'
         + '不要对用户说"系统不会校验必填项"。';
 }
 // ---------------------------------------------------------------------------
@@ -1281,6 +1653,10 @@ async function loadCreateFormPack(workflowId, env) {
     return { data, launchPreferences };
 }
 async function commandCreateForm(args, env) {
+    // ★ 2026-10-16 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
+    // 起点取在函数入口（含下面那次会话惰性初始化），终点取在结果产出之后 —— 即"从命令开始执行到
+    // 执行完成"。取值不做开关、不进 skill 文档（用户明确要求"直接默认加上"）。
+    const startedAt = Date.now();
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
     // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
     await env.host.getSession();
@@ -1299,11 +1675,38 @@ 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` / `launchPreferences`，TS 的推断会**丢掉索引签名**、只留这两个显式键。
+    const fullPayload = {
         ...pack.data,
         workflow: { ...(pack.data.workflow || {}), selectionSource: target.source },
         launchPreferences: pack.launchPreferences,
-    }, env, 'last_create_form.json'));
+    };
+    const compacted = await compactFormOutput(fullPayload, env, 'last_create_form.json', [], {
+        safeChars: CREATE_FORM_STDOUT_SAFE_CHARS,
+        operation: 'workflow.createForm',
+        // 判线要量"最终打出去的那份文本"，而 `durationMs` 的真值只能在压缩**之后**求（它统计的正是
+        // 整条命令），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘（安全方向）。
+        reserve: { durationMs: DURATION_RESERVE_SENTINEL },
+    });
+    // 耗时并在 `data` 里（与 `outputChars` / `persistedResult` 这些运行期属性同处）；**两条分支都带上**
+    // —— 超线落盘那一档 `data` 只剩一句提示，并进去它才不会恰好在"大表单"时消失。
+    return workflowSuccess('workflow.createForm', { ...compacted, durationMs: Date.now() - startedAt });
 }
 // ---------------------------------------------------------------------------
 // createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
@@ -1317,6 +1720,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 +1840,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) && 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 +1930,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 +1991,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 +2044,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 +2066,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 +2117,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,
@@ -2000,6 +2460,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';
@@ -2122,7 +2695,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 +2728,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)) {
@@ -2865,6 +3448,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 +3849,289 @@ 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,6 +4176,167 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
     return result;
 }
 // ---------------------------------------------------------------------------
+// 小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`）按**行号升序**取值、用 `;` 连接；主表字段就是它自己的值。
+ * 值为空（没解析出内容）的字段整个省略，不生成空参数。
+ */
+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>`;
+}
+// ---------------------------------------------------------------------------
 // createRequest（合并原 createPrepare + createApply）
 // ---------------------------------------------------------------------------
 /**
@@ -3346,13 +4383,30 @@ 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);
+    const linkageDetails = isXiaoE
+        ? []
+        : await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false);
     // 明细默认值无行号，而判缺失/写载荷都按行号索引 ⇒ 按用户已建行补齐缺口（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
+        ? 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 +4444,52 @@ async function commandCreateRequest(args, env) {
     }
     const missingAll = [...missing, ...systemMissing];
     /**
-     * 历史参考值（V12.1.77）：取数已在 `createForm` 做完，这里**只从句柄里的缓存筛**，不再联网。
+     * 历史参考值在 `createRequest` 一侧**不再返回**（V12.1.102 撤出；V12.1.77 曾在这里从句柄缓存
+     * 筛"这次新出现的必填字段"的历史值一并给回）。
      *
-     * 只筛「**这次新出现**的必填字段」——即 `createForm` 当时还没被判成必填、模型因此没见过的那些
-     * （绝大多数是联动命中后才变成必填的字段）。`createForm` 已经给过历史值的字段不再重复返回：
-     * 那些值模型本来就拿到了，重复给只是白占上下文。
+     * 撤出理由（2026-10-13 真机复核）：文档口径早已明令 `NEEDS_INPUT` / `NEEDS_CONFIRMATION` 时
+     * `historyRequestData` **一律不看、不用**（必填缺失直接一次问齐用户，不做任何值推断）——这份数据
+     * 于是只剩副作用：既白占返回体积（真机 3,649 B 里占 2,173 B＝60%，且 5 条记录还是同一组值的
+     * 重复），又逼模型多烧一轮说服自己"不要看"，返回值与规则自相矛盾。
      *
-     * `createForm` 缓存是"本表单全部字段"的宽结果（`allFormFields`），所以新字段也能命中；
-     * 缓存取不到 / 一个值都没命中 ⇒ `null`（不塞空数组）。句柄不是本机签发、或会话跨版本升级时
-     * 缓存可能缺失，此时退化为 `null`——纯辅助信息，不阻断任何流程。
+     * 历史参考值的唯一入口回到 `createForm`（那边给的仍是"本表单静态必填字段"的参考值）。
+     *
+     * 2026-10-13 晚补（用户口径）：原始历史**仍然不返回**给模型，但命令**内部**继续用它——
+     * 为缺失的必填字段算一条「历史取值一致」的**推荐值**渲染进 `finalMarkdown`（见
+     * `historyRecommendation`）。这样用户能一句话确认，而"一致性判断"这件容易让模型绕圈的事
+     * 全部留在命令侧，模型拿到的仍是一份可直接粘贴的文本。
      */
-    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))
+    /**
+     * 「已填内容」的两组行（2026-10-14 用户口径）：**系统字段（流程标题等）在前、业务字段按表单
+     * 布局顺序随后**，两份渲染档（必填缺失 / 已落地）共用同一份口径。值取自 `merged2`
+     * （表单默认值 + 本次入参 + 联动带出的值），也就是"用户在表单上看到的那一份"。
+     *
+     * 真机现场：用户看到的「已填内容」只有模型显式传的两项，而表单上明明还有一批**已填状态**的
+     * 字段（表单默认值、流程标题）——用户无法据此确认"这张单到底填成什么样了"。
+     */
+    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 +4501,76 @@ 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 形态**（同日第二次裁定「xiaoe 下应该直接输出 `<browsertool>` 标签」）：这一档的 stdout
+     * **就是那段标签块本身，不套 JSON 信封** —— 判定与落点都在 `shortcuts/workflow/index.ts` 的
+     * `rawStdoutOf()` / `executeAndPrint()`（放在命令层是因为"打到 stdout 的形态"属命令层职责）。
+     * 所以下面的 `message` / `workflow` 等键**不会出现在 stdout 上**，它们只对 `--input-ref` 这类
+     * 程序化消费者有意义；模型侧看到的就是标签块，读法见 `workflow-create.md` 第 3 步与处置表。
+     *
+     * 判据：`auth/xiaoe.ts` 的 `hasXiaoEEnv(env.ctx.env)`（2026-10-16 用户裁定，统一走公共判据）。
+     * 它已覆盖宿主的两种形态 —— 网页端（`XIAOE_USER_TOKEN` + `XIAOE_DOMAIN` 平台凭证）与桌面客户端
+     * （`XIAOE_DATA_ROOT` / `XIAOE_ROBOT_DATA_ROOT` / `XIAOE_USER_SETTINGS_PATH` / `XIAOE_ROBOT_ROOT`
+     * 四个运行期路径变量），同时仍对 `WORKBUDDY_*` / `CODEX_*` 做排他短路。本处复用上面算好的
+     * `isXiaoE`（同一判据，只求值一次）。
+     *
+     * 本档**不跑字段联动、也不跑显示属性联动**（2026-10-16 用户裁定，见上方 `isXiaoE` 的注释）：
+     * 所以这里既没有「字段联动带出」的提示，`hiddenSubforms` / `rowExtraRequired` / `rowDisabled`
+     * 也都是空集 —— 该由浏览器页面在表单里自己算。
+     */
+    if (isXiaoE) {
+        // `src` 要的是绝对地址：句柄里带走的那份 baseUrl 为准（与句柄同源，避免"换了域名后旧句柄拼出别的站"），
+        // 旧版本句柄可能没带 ⇒ 回落到当前会话的 baseUrl。
+        const xiaoEBaseUrl = String(context.baseUrl ?? '') || (await getSessionContext(env)).baseUrl;
+        return workflowSuccess('workflow.createRequest', {
+            status: 'BROWSER_FILL',
+            contextId: token,
+            message: '当前是小e环境：本次不向服务端写入，改由浏览器页面完成填单。命令已把 <browsertool> 标签块直接输出到 stdout（本档不打 JSON 信封），把那段输出原样作为本轮回复正文即可（不要包在代码块里、不要加任何前后说明）。',
+            workflow: context.workflow,
+            finalMarkdown: renderXiaoEFillFormMarkdown({
+                baseUrl: xiaoEBaseUrl,
+                title: String(context.workflow?.name ?? ''),
+                workflowId: String(context.workflow?.id ?? context.runtime?.workflow_id ?? ''),
+                customParams: xiaoECustomParams(preview),
+            }),
+        });
+    }
     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();
         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,6 +4774,12 @@ 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]);
+    }
     return workflowSuccess('workflow.createRequest', result);
 }
 function formatRemark(value) {