weaver-work-cli 0.1.23 → 0.1.24

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

@@ -17,11 +17,12 @@
  */
 import { randomUUID } from 'node:crypto';
 import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CONTINUATION, SCHEMA_CONFIRM, } from './types.js';
-import { responseData, toArray, withLeadingMeta, stdoutBytesOf, STDOUT_SAFE_BYTES, parseNameWithId, resolveMemoryAppId, } from './shared.js';
+import { asBool, responseData, toArray, withLeadingMeta, stdoutBytesOf, 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 { continuationReplayError } from '../continuation.js';
 import { writeStateFileBestEffort } from '../state.js';
+import { buildHistoryRequestData, filterHistoryRequestData } from './read.js';
 // ---------------------------------------------------------------------------
 // 常量（与 Python 源逐条对齐）
 // ---------------------------------------------------------------------------
@@ -47,287 +48,57 @@ const SYSTEM_FIELD_KEYS = {
 const ATTACH_SIZE_LIMIT_STEPS_MB = [1, 5, 10, 20, 50, 100];
 const CONTINUATION_TTL_MS = 10 * 60 * 1000;
 /**
- * `fields` 的紧凑编码（通用）。
- *
- * 字段多的表单里，`fields` 的键名要重复 N 次；pretty 输出下每个字段还会占掉 4~6 行缩进
- * —— 实测某 278 字段的表单 `fields` 占 35.8KB，其中键名 + 缩进比真实数据还多。这里改成
- * "一行一个字段、列用 `|` 分隔"的字符串数组：省掉重复键名，也只占一行缩进。
- *
- *   "columns": ["id","name","subFormId","componentKey"],
- *   "rows": ["856266610411798602|Cost Bearer||MultiContent", …],
- *   "extra": { "<字段id>": { "required": true, "isBrowser": true, "options": [ … ] } }
- *
- * 非列信息（required / readOnly / isBrowser / options / fileUploadParams…）条目少，
- * 仍按字段 id 登记在 `extra`。信息不丢：完整结构写在 resultFile，这里只是换一种编码。
- */
-function encodeFieldsCompact(fields) {
-    const columns = ['id', 'name', 'subFormId', 'componentKey'];
-    const cell = (value) => String(value === undefined || value === null ? '' : value).replace(/[|\r\n]/g, ' ');
-    const rows = fields.map((field) => columns.map((col) => cell(field?.[col])).join('|'));
-    const extra = {};
-    for (const field of fields) {
-        if (!field || typeof field !== 'object')
-            continue;
-        const rest = {};
-        for (const [key, value] of Object.entries(field)) {
-            if (!columns.includes(key))
-                rest[key] = value;
-        }
-        if (Object.keys(rest).length)
-            extra[String(field.id ?? '')] = rest;
-    }
-    return { columns, rows, rowCount: rows.length, extra };
-}
-/**
- * `fields` 被整体移出 stdout 时的补偿索引（V12.1.34）。
+ * 大表单输出保护（通用，不针对任何具体工作流/表单）。
  *
- * 极端档（`fieldsOmitted`）此前只留 `requiredFields` / `subFormRequired` / `editableFields`
- * 三个**纯 id 数组**，模型拿不到「字段名 ↔ 字段 id」的对应关系，只能自己写脚本去 resultFile 里挖
- * （实测某次会话为此多写 3 个脚本、3 次被 head 截断，白花 6 次工具往返）。
- * 这里补一份**只含可写字段**的紧凑索引（行 = `id|name|subFormId|componentKey|flags`），
- * 体积很小（某 278 字段表单实测 3.7KB，其余字段 17.5KB，合计 21.2KB < 安全线），
- * 足以让模型直接构造 `data` 的键。
+ * 字段多的表单，`createForm` / `editLoad` 的输出能轻松超过 60KB，会被宿主截断成 2KB 预览；
+ * 模型于是自己写脚本、分段读取，白花好几轮工具往返。这里对齐 `todoStat` 的做法：超安全线时把
+ * **完整结果**写入 resultFile，stdout **只回一条提示** —— 落盘路径 + 一条可照抄执行的读文件命令。
  *
- * V12.1.37（2026-09-23）：把两类**填值前就要核对、又恰好不在行内**的属性随索引下发 ——
- * 它们此前只能去 resultFile 取，实测就是那次「二次读取」的主要动因：
- * - `formatIndex`（字段 id → `format`）：日期/时间字段的格式（`yyyy-MM-dd` 等）。只有 `T` 标记时
- *   模型知道"有格式要求"却不知道要求什么，只能读 resultFile；实测某会话为它多跑一轮 ≈11 s。
- * - `uploadLimits`（字段 id → `大小上限|格式限制|数量上限`）：附件字段的上传限制，见 `uploadLimitOf`。
+ * 2026-09-29 用户裁定：此前超线时还会回「摘要 + 紧凑编码 `fields` + `writableFields` 补偿索引」，
+ * 实测反而把模型带进"先看看手里有什么、再决定读不读文件"的分叉：某次真机会话里落的是**只剩指针**
+ * 那一档（`fields` / `writableFields` / `editableFields` 全被移出 stdout），模型于是先 grep 找
+ * `writableFields`、再读 `requiredFields`、发现 `fields` 是完整对象后又按 17 个字段 id 批量 grep，
+ * **从头到尾没读那个文件**。现在超线只有一条路：照抄命令读文件。
  *
- * 仍需按字段 id 去 resultFile 取的只剩 `browserModule` / `browserType` / 完整 `options` 结构等
- * 低频元数据。纯结构裁剪，不做任何语义判断。
+ * **返回体里不再有任何表单属性** —— 字段清单、必填、历史参考值、`contextId` / `continuation`
+ * 全部只在 resultFile 里，所以提示必须把"不读就没法继续"说透。
  *
- * @param writableIds   可写字段 id（含系统字段），顺序即输出顺序的同构子集
- * @param sourceFields  字段来源。**必须传已挂上 `fileUploadParams` / `folderDependsOnOption` 的那份**
- *                      （createForm 传 `slimFields`；传早期的 `visibleFields` 会让 F/D 两个标记恒不出现）
- * @param systemNames   系统字段 id → 中文名（不在 sourceFields 里的兜底）
+ * 落盘不可用时没有文件可指，只能保持全量输出（宁大不丢数据），只补一句说明。
  */
-function encodeWritableFieldsCompact(writableIds, sourceFields, systemNames) {
-    const byId = new Map();
-    for (const f of sourceFields)
-        byId.set(String(f?.id ?? ''), f);
-    const cell = (value) => String(value === undefined || value === null ? '' : value).replace(/[|\r\n]/g, ' ');
-    const flagsOf = (f) => {
-        const component = String(f.componentKey ?? '').toLowerCase();
-        let flags = '';
-        if (f.required)
-            flags += 'R';
-        if (f.isBrowser)
-            flags += 'B';
-        if (f.isSelect)
-            flags += 'S';
-        if (f.isMultiple)
-            flags += 'M';
-        if (component === 'employeescope')
-            flags += 'E';
-        if (component === 'einvoicecomponent')
-            flags += 'V';
-        if (f.folderDependsOnOption)
-            flags += 'D';
-        if (f.fileUploadParams)
-            flags += 'F';
-        if (Array.isArray(f.options) && f.options.length)
-            flags += 'O';
-        if (String(f.format ?? '').trim())
-            flags += 'T';
-        return flags;
-    };
-    const rows = [];
-    const optionIndex = {};
-    const formatIndex = {};
-    const uploadLimits = {};
-    const emitted = new Set();
-    const push = (id) => {
-        if (emitted.has(id))
-            return;
-        emitted.add(id);
-        const f = byId.get(id);
-        if (!f) {
-            rows.push([id, systemNames[id] || '', '', '', ''].map(cell).join('|'));
-            return;
-        }
-        rows.push([id, f.name, f.subFormId, f.componentKey, flagsOf(f)].map(cell).join('|'));
-        const options = Array.isArray(f.options) ? f.options : [];
-        if (options.length) {
-            optionIndex[id] = options.slice(0, 30).map((o) => (o && typeof o === 'object' ? String(o.name ?? o.content ?? '') : String(o)));
-        }
-        const format = String(f.format ?? '').trim();
-        if (format)
-            formatIndex[id] = format;
-        const limits = uploadLimitOf(f);
-        if (limits)
-            uploadLimits[id] = limits;
-    };
-    const wanted = new Set(writableIds);
-    for (const f of sourceFields) {
-        const id = String(f?.id ?? '');
-        if (wanted.has(id))
-            push(id);
-    }
-    for (const id of writableIds)
-        push(id);
-    const out = {
-        columns: ['id', 'name', 'subFormId', 'componentKey', 'flags'],
-        rows,
-        rowCount: rows.length,
-        flagLegend: 'R=必填 B=浏览按钮 S=选项 M=多选 E=人员范围 V=发票 D=附件目录随选项 '
-            + 'F=有上传参数(见 uploadLimits) O=有选项(见 optionIndex) '
-            + 'T=有日期/时间格式要求(见 formatIndex)',
-    };
-    if (Object.keys(optionIndex).length)
-        out.optionIndex = optionIndex;
-    if (Object.keys(formatIndex).length)
-        out.formatIndex = formatIndex;
-    if (Object.keys(uploadLimits).length)
-        out.uploadLimits = uploadLimits;
-    return out;
-}
+/** 落盘不可用时的叮嘱（此时没有文件可读，只能就地把输出读完）。 */
+const READ_WHOLE_OUTPUT_HINT = '读取本输出请一次读完：不要用 head/tail 等管道截断'
+    + '（截断会破坏 JSON，并导致重复执行同一条命令）。';
 /**
- * 附件字段的上传限制 → 一行紧凑描述（`大小上限|格式限制|数量上限`）。
+ * 超线时的**唯一**返回内容：落盘路径 + 一条可直接照抄的读文件命令（措辞由用户 2026-09-29 指定）。
  *
- * 只摘模型填值前要核对的三项，**丢掉服务器侧管道**：`customParam`（`authStr`/`authSignatureStr`/
- * `requestId`/`nodeId`/`identityId`…）、`folderId`/`refId`/`sourceRefId`/`source`/`module` 等，
- * 单字段原块 ≈700 B 而其中三项限制合计不到 120 B。
+ * 用户明确要求：① 超线**只回提示**，不再回任何精简属性 —— 否则模型会先思考一段再决定读不读；
+ * ② 提示里**直接给出可执行的读命令**（工具 + `file_path` + 精确 `limit`），避免模型自己把 `limit`
+ * 给小了、于是分段读好几次；③ **除这两行外一个字都不要**（原话："其余内容都去掉"）。
  *
- * - `sizeLimit` 单位 MB；`formatLimit.mode='white'` 记「白名单」、其余记「黑名单」；
- *   `formats=['*.*']`（或 `['*']`）记「不限格式」。
- * - 缺项一律写 `-`，**不要留空**：留空会被读成"限制为 0/不允许"。
- * - 无 `fileUploadParams` 的字段返回空串（调用方不产出该条目）。
+ * `lines` 是落盘文件的总行数，正好是一次读完所需的 `limit`。文件读取工具不受宿主 stdout 那条
+ * ~30 KB 内联线约束（实测 76 KB / 238 KB 都能一次读回）。
  */
-function uploadLimitOf(f) {
-    const params = (f && typeof f === 'object') ? f.fileUploadParams : null;
-    if (!params || typeof params !== 'object')
-        return '';
-    const size = Number(params.sizeLimit);
-    const maxNum = Number(params.maxNum);
-    const limit = (params.formatLimit && typeof params.formatLimit === 'object') ? params.formatLimit : null;
-    const formats = Array.isArray(limit?.formats)
-        ? limit.formats.map((v) => String(v).trim()).filter(Boolean)
-        : [];
-    const formatText = !formats.length
-        ? '-'
-        : (formats.length === 1 && (formats[0] === '*.*' || formats[0] === '*'))
-            ? '不限格式'
-            : `${String(limit?.mode ?? '').toLowerCase() === 'white' ? '白名单' : '黑名单'}:${formats.join(',')}`;
-    return [
-        Number.isFinite(size) && size > 0 ? `${size}MB` : '-',
-        formatText,
-        Number.isFinite(maxNum) && maxNum > 0 ? `${maxNum}个` : '-',
-    ].join('|');
+function resultFileNotice(resultFile, lines) {
+    return `表单内容较大，已写入临时文件（resultFile：${resultFile}），无需思考，直接运行下面的命令读取完整表单内容：`
+        + `\nRead(file_path: "${resultFile}", limit: ${lines})`;
 }
-/**
- * 大表单输出保护（通用，不针对任何具体工作流/表单）。
- *
- * 字段多的表单，`createForm` / `editLoad` 的输出能轻松超过 60KB，会被宿主截断成 2KB 预览；
- * 模型于是写脚本读回、读回又被截断，白花好几轮工具往返（实测某次会话为此多花 5 次）。这里
- * 对齐 `todoStat` 的做法：超安全线时把**完整结果**写入 resultFile，stdout 只回精简版并前置
- * `resultFile`（放最前，被截断也看得见），同时把 `fields` 换成列式编码。
- *
- * 落盘不可用时保持全量输出（宁大不丢数据），只补一句说明。
- *
- * V12.1.34：入口可传 `fieldsOmittedCompensation`（可写字段紧凑索引）。它**只在 `fields` 真的被
- * 整体移出 stdout 时**才随摘要一起产出 —— 紧凑编码那一档 `fields` 仍在，模型本来就能读到字段名，
- * 不需要重复体积；小表单（未超线）完全不产出，避免无谓地把输出顶到安全线上。
- */
-/** 读取本输出的统一叮嘱（紧凑版与兜底版共用）。 */
-const READ_WHOLE_OUTPUT_HINT = '读取本输出请一次读完：不要用 head/tail 等管道截断'
-    + '（截断会破坏 JSON，并导致重复执行同一条命令）；本输出被截断读不全时直接读 resultFile，不要重跑本命令。';
-async function compactFormOutput(result, env, resultFileName, fieldsOmittedCompensation) {
+async function compactFormOutput(result, env, resultFileName) {
     const bytes = stdoutBytesOf(result);
+    // 未超本地安全线 ⇒ 原样返回，不做任何裁剪、也不落盘。
     if (bytes <= STDOUT_SAFE_BYTES)
         return result;
-    const fields = toArray(result.fields);
-    const resultFile = await writeStateFileBestEffort(resultFileName, JSON.stringify(result, null, 2), env.ctx);
+    const payload = JSON.stringify(result, null, 2);
+    const resultFile = await writeStateFileBestEffort(resultFileName, payload, env.ctx);
     if (!resultFile) {
-        return {
-            ...result,
-            outputBytes: bytes,
-            largeOutputNotice: `表单字段较多（${fields.length} 个）且本地落盘不可用，已按原样返回全量 fields。`
-                + READ_WHOLE_OUTPUT_HINT,
-        };
+        return { ...result, outputBytes: bytes, largeOutputNotice: READ_WHOLE_OUTPUT_HINT };
     }
-    const compact = withLeadingMeta({
-        resultFile,
-        persistedResult: true,
-        outputBytes: bytes,
-        largeOutputNotice: `表单字段较多（${fields.length} 个），完整结果已写入 resultFile。`
-            + 'stdout 里的 fields 是紧凑编码：columns 为列名，rows 每行一个字段、各列用 "|" 分隔'
-            + '（顺序与 columns 一致），extra 按字段 id 存放非列信息'
-            + '（required / readOnly / disableEdit / isBrowser / isSelect / isMultiple / browserModule /'
-            + ' browserType / options / fileUploadParams 等；未出现在 extra 里的字段即为默认值）。'
-            + '需要某字段的完整原始元数据时，从 resultFile 里按该字段 id 取。'
-            + 'resultFile 是完整 pretty JSON、体积很大，请用脚本按需提取，不要整份读入上下文。'
-            + READ_WHOLE_OUTPUT_HINT,
-    }, {
-        ...result,
-        fields: encodeFieldsCompact(fields),
-    });
-    if (stdoutBytesOf(compact) <= STDOUT_SAFE_BYTES)
-        return compact;
-    // 极端兜底（字段极多的表单，紧凑编码也压不进安全线）：stdout 只留指针 + 摘要，
-    // 字段清单去 resultFile 按需提取 —— 否则整段输出会被宿主截成 2KB 预览，等于什么都没拿到。
-    // V12.1.34：随摘要附上**可写字段补偿索引**，模型不必再自己写脚本挖 resultFile。
-    // V12.1.35（实测 278 字段表单：美化 37,887 B → ≈17 KB，落进宿主 28 KB 内联区）：
-    //  ① 安全线改用**美化口径** `stdoutBytesOf()`（与实际 stdout 一致）。此前量压缩 JSON，**低估 1.79 倍**
-    //     ⇒ 这一档从未触发，且 `writableFields` 被追加在末尾（起始偏移 31,093），宿主只给 2048 B 预览
-    //     ⇒ 模型永远看不到它，只能自写脚本挖 resultFile（实测白烧 4 轮工具往返、约 54 s）。
-    //  ② `editableFields`（与 writableFields 冗余）移出 stdout，只留可写索引 — 二者合起来才够把体积压进宿主内联区。
-    //  ③ `writableFields` 前置到载荷最前，任何截断场景下都先被看到。
-    const summary = { ...result };
-    delete summary.fields;
-    delete summary.editableFields;
-    /**
-     * "字段清单去哪了"的文案——`withIndex` 表示**本档是否真的带了** `writableFields`。
-     *
-     * 2026-09-22 修正：只留指针那一档此前复用同一段文案，于是在**没给索引的档位里声称"已给出索引"**，
-     * 既与同档的 `writableFieldsOmitted: true` 标记互相矛盾，又把模型指向一个不存在的键。
-     *
-     * 2026-09-23 修正：文案此前只提 `optionIndex`，还把 `fileUploadParams` 列进"要读 resultFile"的清单 ——
-     * 而 `formatIndex` / `uploadLimits` 其实**已经随索引下发**，本可覆盖"日期格式""上传限制"这两个最常见的
-     * 回读动因。文案不提它们，等于默许模型为这两项去读 resultFile（实测就是这么白跑一轮）。现按实际下发的
-     * 三类索引（`optionIndex` / `formatIndex` / `uploadLimits`，均按需出现）改写，并删掉 `fileUploadParams`。
-     */
-    const fieldsOmittedNoticeOf = (withIndex) => `表单字段过多（${fields.length} 个），字段清单已整体移出 stdout，`
-        + '完整结果（含全部 fields 原始元数据）已写入 resultFile。'
-        + (withIndex
-            ? 'stdout **最前面**已给出全部可写字段的紧凑索引 writableFields：columns 为列名、rows 每行一个字段'
-                + '（`id|name|subFormId|componentKey|flags`，flags 含义见 flagLegend）。填值前要核对的映射'
-                + '也随同一索引下发：选项名见 optionIndex、日期/时间格式见 formatIndex、附件上传限制见 uploadLimits'
-                + '（三者按需出现，没有该类字段时没有该键）。**直接用 writableFields 里的字段 id 构造 data 的键**，'
-                + '选项、日期格式、上传限制一律照上述索引填 —— 不要为了拿字段清单、选项、格式或上传限制再写脚本解析 resultFile；'
-                + '只有需要这里没有的字段元数据（browserModule / browserType / 完整 options 结构）时，'
-                + '才按该字段 id 从 resultFile 取。'
-            : '本档体积太紧，**可写字段索引也放不进 stdout**——构造表单数据前，请按字段 id 从 resultFile 里提取所需键，'
-                + '按需只取几个键、不要把整份 resultFile 读入上下文。');
-    const metaOf = (withIndex = true) => ({
+    // 只回提示：路径说明 + 读命令（`resultFile` 排最前，被截断也看得见）。
+    return withLeadingMeta({
         resultFile,
         persistedResult: true,
         outputBytes: bytes,
-        fieldsOmitted: true,
-        fieldCount: fields.length,
-        largeOutputNotice: fieldsOmittedNoticeOf(withIndex) + READ_WHOLE_OUTPUT_HINT,
-    });
-    const orderedBody = (includeWritable = true) => {
-        const out = {};
-        if (includeWritable && fieldsOmittedCompensation)
-            out.writableFields = fieldsOmittedCompensation;
-        for (const [key, value] of Object.entries(summary)) {
-            if (value !== undefined)
-                out[key] = value;
-        }
-        return out;
-    };
-    // 第一档：可写字段索引 + 摘要（正常的大表单都落在这里）
-    const withIndex = withLeadingMeta(metaOf(true), orderedBody(true));
-    if (stdoutBytesOf(withIndex) <= STDOUT_SAFE_BYTES)
-        return withIndex;
-    // 第二档（字段数量极端）：索引也放不进安全线，退回只留指针，并显式标注索引被省略了。
-    // 2026-09-22 修正：这一档**必须真的把 writableFields 去掉**——此前仍经 `orderedBody(true)` 把它塞回去，
-    // 结果既没压进安全线，又与 `writableFieldsOmitted: true` 自相矛盾、文案还在说"已给出索引"。
-    return withLeadingMeta({
-        ...metaOf(false),
-        ...(fieldsOmittedCompensation ? { writableFieldsOmitted: true } : {}),
-    }, orderedBody(false));
+        largeOutputNotice: resultFileNotice(resultFile, payload.split('\n').length),
+    }, {});
 }
 async function requestJson(env, method, path, query, body, options = {}) {
     const response = await env.host.workflowRequest({
@@ -591,6 +362,50 @@ function buildLayoutRequest(workflowId, runtime, frame) {
 // ---------------------------------------------------------------------------
 // 字段提取（extractFields）
 // ---------------------------------------------------------------------------
+/**
+ * 从 `title` 这类"可能是字符串、也可能是对象"的值里取出展示文本。
+ *
+ * 真机（2026-09-29「会议申请」）：布局里 `title` **不保证是字符串** —— `NewButton` 组件给的是
+ * `{nameAlias: "会议室使用情况"}`。旧实现直接 `String(raw.title)`，于是 `fields[].name` 出现了
+ * `"[object Object]"`：模型拿着这个名字既认不出字段，也没法向用户复述。
+ */
+const TITLE_TEXT_KEYS = ['nameAlias', 'zh_CN', 'zhCN', 'name_zh', 'text', 'label', 'value', 'content', 'name', 'title'];
+function textOfTitleValue(value, depth = 0) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (!value || typeof value !== 'object' || depth >= 3)
+        return '';
+    for (const key of TITLE_TEXT_KEYS) {
+        const inner = value[key];
+        if (inner === undefined || inner === null)
+            continue;
+        const text = textOfTitleValue(inner, depth + 1);
+        if (text.trim())
+            return text;
+    }
+    return '';
+}
+/**
+ * 字段展示名：`title` 优先（对象先取文本），再回落 `name` / `dataKey` / 字段 id。
+ *
+ * 同时清掉 `[object Object]` —— 服务端自己拼 `MultiContent` 容器标题时就有 Java 拼接 bug
+ * （真机实例 `"会议地点;[object Object]"`，`title` 本身就是这么个字符串），残留段去掉后
+ * 再收掉空的分段，免得把服务端的缺陷当成字段名传给模型。
+ */
+function fieldTitleOf(raw, fieldId) {
+    const text = (textOfTitleValue(raw.title, 0)
+        || textOfTitleValue(raw.name, 0)
+        || textOfTitleValue(raw.dataKey, 0))
+        .replace(/\[object Object\]/gu, '')
+        .split(';')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join(';')
+        .trim();
+    return text || fieldId;
+}
 function extractFields(layoutData, requiredMap, disableEditMap, displayMap) {
     const candidates = {};
     const walk = (value) => {
@@ -638,7 +453,7 @@ function extractFields(layoutData, requiredMap, disableEditMap, displayMap) {
         const isSelect = SELECT_COMPONENTS.has(normalized) || options.length > 0;
         result.push({
             id: fieldId,
-            name: String(raw.title ?? raw.name ?? raw.dataKey ?? fieldId),
+            name: fieldTitleOf(raw, fieldId),
             componentKey: component,
             required: (requiredMap[fieldId] !== undefined) ? requiredMap[fieldId] : Boolean(raw.required || raw.mustInput),
             disableEdit: (disableEditMap[fieldId] !== undefined) ? disableEditMap[fieldId] : Boolean(raw.disableEdit),
@@ -1222,7 +1037,7 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
     // 澄清文案里回显的是**用户原话**（不是切分后的关键词）——用户要能认出自己给的条件
     const queryText = rawTerms.join('、');
     if (!rawTerms.length) {
-        throw workflowClarificationError('workflow', '', '要发起哪个流程？请提供可发起工作流的名称、`名称(ID)` 或工作流 ID 后再继续。');
+        throw workflowClarificationError('workflow', '', '要发起哪个流程？请提供该流程的完整名称（或其它可用于检索的关键词）后再继续。');
     }
     // 先做**纯本地**的解析：显式 ID（`名称(ID)` / 纯数字）与名称关键词（一格可含多个，见
     // `splitCreateKeywords`）。这一步不依赖远端结果，于是能先判"到底有没有可用条件"——
@@ -1248,7 +1063,7 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
         }
     }
     if (!explicitIds.size && !nameTerms.length) {
-        throw workflowClarificationError('workflow', queryText, '要发起哪个流程？请提供可发起工作流的名称、`名称(ID)` 或工作流 ID 后再继续。');
+        throw workflowClarificationError('workflow', queryText, '要发起哪个流程？请提供该流程的完整名称（或其它可用于检索的关键词）后再继续。');
     }
     const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, {
         wfpBelongTypeCode: '1', loadOfsFlow: '0', clientCtrl: 1,
@@ -1302,7 +1117,7 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
         })));
     }
     throw workflowClarificationError('workflow', queryText, `「${queryText}」在当前账号下没有匹配到可发起的工作流（也可能已停用或无发起权限）。`
-        + '请核对名称，或给出准确的完整名称 / 工作流 ID 后再继续。');
+        + '请核对名称，或给出该流程更完整的名称（或其它可用于检索的关键词）后再继续。');
 }
 /**
  * 从「全局 + 该工作流维度」的合并记忆里**只取工作流维度那一段**。
@@ -1433,7 +1248,7 @@ function readCreateFormBlock(base) {
  */
 function createFormBlockedError(workflowId, block) {
     if (block.reason === 'workflow_not_exist') {
-        return workflowClarificationError('workflow', workflowId, `工作流 ID「${workflowId}」不存在（可能已删除或被停用）。请核对 ID，或直接给出流程名称重新指定。`, [], { clarificationReason: 'workflow_not_exist' });
+        return workflowClarificationError('workflow', workflowId, `工作流「${workflowId}」不存在（可能已删除或被停用）。请改用该流程的完整名称（或其它可用于检索的关键词）重新指定。`, [], { clarificationReason: 'workflow_not_exist' });
     }
     return workflowClarificationError('workflow', workflowId, `工作流 ID「${workflowId}」**存在**，但当前账号没有发起权限`
         + `${block.detail ? `（${block.detail}）` : ''}。`
@@ -1458,12 +1273,12 @@ function singleExplicitWorkflowId(rawWorkflow) {
 }
 /** 表单载入 + 该工作流的发起偏好：两者只共享 `workflowId`，可以并行。 */
 async function loadCreateFormPack(workflowId, env) {
-    const [{ data, writableFieldsCompact }, launchPreferences] = await Promise.all([
+    const [{ data }, launchPreferences] = await Promise.all([
         buildCreateFormData(workflowId, env),
         // 记忆读取是 best-effort（内部全 catch），不会把表单载入的错误顶掉。
         fetchLaunchPreferences(workflowId, env),
     ]);
-    return { data, writableFieldsCompact, launchPreferences };
+    return { data, launchPreferences };
 }
 async function commandCreateForm(args, env) {
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
@@ -1488,7 +1303,7 @@ async function commandCreateForm(args, env) {
         ...pack.data,
         workflow: { ...(pack.data.workflow || {}), selectionSource: target.source },
         launchPreferences: pack.launchPreferences,
-    }, env, 'last_create_form.json', pack.writableFieldsCompact));
+    }, env, 'last_create_form.json'));
 }
 // ---------------------------------------------------------------------------
 // createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
@@ -1689,14 +1504,16 @@ async function buildCreateFormData(workflowId, env) {
     }
     const slimFields = [];
     for (const field of visibleFields) {
-        const item = {
-            id: field.id,
-            name: field.name,
-            subFormId: field.subFormId,
-            componentKey: field.componentKey,
-        };
-        if (field.required)
-            item.required = true;
+        // 键序 id|name|subFormId|componentKey 是契约；`subFormId` **为空就整个省略**（缺该键＝主表字段）
+        // —— 主表字段占绝大多数，写 `""` 恒白占一条键（真机 278 字段表单：100 个主表字段 × 22 B ≈ 2.2 KB）。
+        const slimSubFormId = String(field.subFormId ?? '');
+        const item = { id: field.id, name: field.name };
+        if (slimSubFormId)
+            item.subFormId = slimSubFormId;
+        item.componentKey = field.componentKey;
+        // `fields` **不返回** `required`：必填只从 `requiredFields`（主表）/ `subFormRequired`（明细）取。
+        // `fields` 是布局级字段全集（含联动隐藏、未在当前页展示的字段），在这里标必填会让模型
+        // 拿它去推演"能填什么 / 哪些是必填"，与真实可填集合（`editableFields`）混淆。
         if (field.readOnly || field.disableEdit) {
             item.readOnly = Boolean(field.readOnly);
             item.disableEdit = Boolean(field.disableEdit);
@@ -1763,6 +1580,30 @@ async function buildCreateFormData(workflowId, env) {
             iv.subFormId = sf;
         initValues.push(iv);
     }
+    /**
+     * 必填字段 → 历史可参考值（V12.1.77：取数点从 `createRequest` **前移到这里**）。
+     *
+     * 为什么前移到 createForm：
+     * - 模型现在能在**第一次** `createRequest` 之前就拿到"这张表单的必填项，历史单里通常填什么"，
+     *   于是很多必填项不必再问用户（等 `createRequest` 才发现缺失时，已经多花了一轮往返）。
+     * - `createRequest` 侧退化成"只从缓存里筛"，**不再联网取数**——缺失字段反复出现时也不会重复查。
+     *
+     * 缓存口径（`allFormFields`）：保留**本表单**所有能取到值的字段，而不只是当前的必填字段。
+     * 原因：条件必填由联动实时算出，`createForm` 阶段根本不知道哪些字段最终会变成必填；只有缓存
+     * 放宽到"本表单全部字段"，`createRequest` 才能对**新出现的**必填字段给出历史值。
+     * 范围靠"本表单字段 id"收口（`fieldMeta` 只含 `fields` 里的字段），不会把别的表单的字段带进来；
+     * 另把查询条件钉在**本次要发起的工作流**上（`workflowId`）——不同表单的字段 id 不通用，
+     * 不收窄的话"最近 5 条我发起的"很可能一条都不是本表单 ⇒ 白查两次接口还拿不到值。
+     *
+     * 只在表单真的有字段时取数；失败一律降级为 `null`，绝不拖垮 `createForm`（见 read.ts 取数注释）。
+     */
+    const historyRequiredFieldIds = [...new Set([
+            ...requiredFieldsList.map((f) => String(f?.id ?? '')),
+            ...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 })
+        : null;
     const session = await getSessionContext(env);
     const context = {
         kind: 'CREATE',
@@ -1804,23 +1645,13 @@ async function buildCreateFormData(workflowId, env) {
         minorInfo,
         tenantSetting,
         onLoadLinkage,
+        // 历史取数的**完整**结果（本表单全部字段）与本次判定出的必填字段集合：随句柄带去
+        // `createRequest`，让它对新出现的必填字段直接筛选，不必再联网（见下方取数注释）。
+        historyCache,
+        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 || {});
-    // 可写字段 = 必填（主表 + 明细，含系统字段）+ 其余可编辑字段。
-    // 只在 `fields` 真被整体移出 stdout 时才会随输出（由 compactFormOutput 决定）。
-    const writableFieldIds = [];
-    for (const id of requiredFieldIds)
-        writableFieldIds.push(id);
-    for (const list of Object.values(subFormRequired)) {
-        for (const f of list)
-            writableFieldIds.push(String(f?.id ?? ''));
-    }
-    for (const f of editableFieldsList)
-        writableFieldIds.push(String(f?.id ?? ''));
-    // 字段来源必须是 slimFields（它才带 fileUploadParams / folderDependsOnOption）：传 visibleFields
-    // 会让 F/D 两个标记恒不出现，uploadLimits 也整块缺失。
-    const writableFieldsCompact = encodeWritableFieldsCompact([...new Set(writableFieldIds)], slimFields, SYSTEM_FIELD_KEYS);
     return {
         data: {
             status: 'FORM_READY',
@@ -1834,9 +1665,17 @@ async function buildCreateFormData(workflowId, env) {
             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: editableFieldsList.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))],
             fields: slimFields,
             initialValues: initValues,
+            // 本表单**必填字段**的历史参考值（近一年、非草稿、最近 5 条「我发起的」）——填值前先看它，
+            // 能直接照用的字段就别去问用户。完整结果（含非必填字段）已随句柄留给 `createRequest` 用。
+            historyRequestData: filterHistoryRequestData(historyCache, historyRequiredFieldIds),
             systemFields: {
                 permissions: minorInfo.permissions || {},
                 defaults: context.systemFields.defaults,
@@ -1848,7 +1687,6 @@ async function buildCreateFormData(workflowId, env) {
             // 原 Python 把完整 context 落盘；此处通过 continuation 承载，返回结构保持文档契约。
             continuation: token,
         },
-        writableFieldsCompact,
     };
 }
 // ---------------------------------------------------------------------------
@@ -2055,6 +1893,106 @@ function assertMultiplicity(field, options) {
         throw new ValueAmbiguity({ kind: 'MULTIPLICITY', fieldId: field.id, fieldName: field.name, reason: '该字段是单选，但输入了多个值', candidates: options });
     }
 }
+/**
+ * 一个字段格子里的「多种说法」拆分（与可发起工作流名称同口径，见 `splitCreateKeywords`）：
+ * 半角/全角逗号分隔 → trim → 丢空 → 去重（保序）。
+ *
+ * 与 `splitCreateKeywords` 的唯一差别：**不做工作流填充词脱壳**——浏览控件取值的名称里
+ * 合法地可能出现「流程」二字（如「流程部会议室」），照搬那套会把名称削坏。
+ */
+function splitValueAliases(raw) {
+    const out = [];
+    const seen = new Set();
+    for (const piece of String(raw ?? '').split(/[,，]/u)) {
+        const token = piece.trim();
+        if (!token || seen.has(token))
+            continue;
+        seen.add(token);
+        out.push(token);
+    }
+    return out;
+}
+/** 浏览按钮字段解析不出来的统一出口。`candidates` **只含关键词真实命中**，绝不用首页枚举冒充。 */
+function browserAmbiguity(field, input, hits) {
+    return new ValueAmbiguity({
+        kind: 'BROWSER',
+        fieldId: field.id,
+        fieldName: field.name,
+        input,
+        reason: hits.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
+        candidates: hits,
+        candidatesAvailable: hits.length > 0,
+        resolution: hits.length
+            ? '把 candidates 原样交给用户确认；用户选定后由你取该项的 id / name 拼出 {"id":…,"name":…} 重发同一条命令（不要让用户提供 ID）。'
+            : '该值在系统里没有匹配。请让用户给出该对象的完整名称，或其它可用于检索的关键词（不要向用户索取 ID）。',
+    });
+}
+/**
+ * 浏览按钮字段「一个字符串 → 一个 {id,name}」的解析。
+ *
+ * 一个格子可写多个**说法**（逗号分隔，与可发起工作流名称同口径），也可写 `名称(id)` 直接给 ID。
+ *
+ * **候选池只取一个来源**（按控件能力二选一，**绝不并集**；来源由 `resolveEntryValues` 按
+ * 控件是否带 `browserModule`+`browserType` 决定，见 `browserFieldCandidates`）：
+ *   - 控件带 `browserModule`+`browserType` ⇒ 只用该控件自己的
+ *     `POST /api/{module}/common/browser/complete/{type}`（服务端按关键词过滤出的列表）；
+ *   - 否则 ⇒ 只用 `nameToId`（`getRelateData`，一个关键词回一条）。
+ *
+ * **采用条件**＝按序判定的四档，命中即采用；**全不命中就澄清**，把去重后的全部候选交给用户确认：
+ *   ① **整串优先**——原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错；真重名则澄清）；
+ *   ② 候选池**恰好一条**（唯一匹配）；
+ *   ③ 某个说法**字面完全同名**、且这样的候选恰好一条；
+ *   ④ 否则澄清。**没有"挑一个最接近的"这一档**。
+ * 显式 ID（`名称(123)`）本身即精确值，直入候选池并按"字面命中"参与 ③，且**不发查询**。
+ *
+ * 之所以不再把 `getRelateData` 的"最佳匹配"直接当命中（V12.1.58 及更早的做法）：它是服务端
+ * 模糊匹配出的**单条**结果，与用户写的词往往并不字面相同——真机「4楼,4」被静默解析成
+ * `142培训室（中庭后侧）` 且不澄清。凡是"多候选+无字面命中"就必须澄清，不再猜。
+ */
+function resolveBrowserAliases(field, raw, lookup) {
+    const dedupe = (items) => {
+        const out = [];
+        for (const item of items) {
+            const id = String(item?.id ?? '').trim();
+            if (!id || out.some((x) => x.id === id))
+                continue;
+            out.push({ id, name: String(item?.name ?? id) });
+        }
+        return out;
+    };
+    const aliases = splitValueAliases(raw);
+    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定
+    const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+    const pool = [];
+    /** 每个词各自「字面同名」的候选（显式 ID 也算字面命中，它本来就是精确值）。 */
+    const literalByTerm = new Map();
+    for (const term of terms) {
+        const parsed = parseNameWithId(term);
+        const candidates = parsed.id
+            ? [{ id: String(parsed.id), name: parsed.name || String(parsed.id) }] // 显式 ID：精确值，不查名
+            : (() => { const hit = lookup(term); return [...hit.mapped, ...hit.completed]; })();
+        pool.push(...candidates);
+        literalByTerm.set(term, candidates.filter((c) => String(c?.name ?? '') === term));
+    }
+    const poolHits = dedupe(pool);
+    // ① **整串优先**：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
+    if (aliases.length > 1) {
+        const wholeHits = dedupe(literalByTerm.get(raw) || []);
+        if (wholeHits.length === 1)
+            return wholeHits[0];
+        if (wholeHits.length > 1)
+            throw browserAmbiguity(field, raw, wholeHits);
+    }
+    // ② 候选池恰好一条 ⇒ 唯一匹配，采用
+    if (poolHits.length === 1)
+        return poolHits[0];
+    // ③ 某个说法字面完全同名、且这样的候选**恰好一条** ⇒ 采用
+    const literalHits = dedupe([...literalByTerm.values()].flat());
+    if (literalHits.length === 1)
+        return literalHits[0];
+    // ④ 否则澄清：把所有去重后的候选一次交给用户确认，绝不挑一个"最接近"的蒙过去
+    throw browserAmbiguity(field, raw, poolHits);
+}
 function normalizeRelateCandidate(value) {
     if (!value || typeof value !== 'object')
         return null;
@@ -2094,7 +2032,7 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 scopeType,
                 input: content,
                 reason: 'NOT_RESOLVED',
-                resolution: `名称「${content}（${scopeType}）」未能解析为 ID，请核对名称，或改用 {"optionId":"候选id","content":"候选名称","type":"${scopeType}"} 后重新 prepare。`,
+                resolution: `名称「${content}（${scopeType}）」未能解析。请让用户给出该对象的完整名称，或其它可用于检索的关键词（不要向用户索取 ID）。`,
             });
         }
         detail.dataOptions = options;
@@ -2126,18 +2064,28 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
         return [detail, options.map((o) => ({ id: o.optionId, name: String((o.optionObj && (o.optionObj.name || o.optionObj.content)) || o.optionId) }))];
     }
     if (String(field.componentKey ?? '').toLowerCase() === 'filecomponent') {
+        // 附件字段的值支持两种形态：
+        //   ① 附件项数组 `[{optionId, content, type}]`——本地新上传后拼出来的；
+        //   ② 历史参考值**原样** `{formField:{id}, dataOptions:[{optionId, content, type}]}`——
+        //      `historyRequestData` 给附件字段的就是它，可整块粘进 `data`（见 workflow-create.md
+        //      的「历史流程数据参考规则」第三条）。这里把 `dataOptions` 剥出来统一处理。
+        const rawItems = (value && typeof value === 'object' && !Array.isArray(value)
+            && Array.isArray(value.dataOptions))
+            ? value.dataOptions
+            : value;
         const options = [];
-        for (const item of listValues(value)) {
+        for (const item of listValues(rawItems)) {
             if (!item || typeof item !== 'object') {
-                throw new ValueAmbiguity({ kind: 'ATTACHMENT', fieldId: field.id, fieldName: field.name, input: item, reason: '附件字段的值必须是附件项数组', resolution: '每项固定格式 {"optionId":"上传返回的file_id","content":"文件名","type":"file"}' });
+                throw new ValueAmbiguity({ kind: 'ATTACHMENT', fieldId: field.id, fieldName: field.name, input: item, reason: '附件字段的值必须是附件项数组（或历史参考值对象）', resolution: '每项形如 {"optionId":"附件ID","content":"文件名","type":"文件类型"}；复用历史附件时可直接传 historyRequestData 里该字段的值' });
             }
             const optionId = String(item.optionId ?? '').trim();
             const content = String(item.content ?? '').trim();
-            const ftype = String(item.type ?? '').trim();
-            if (!optionId || !content || ftype !== 'file') {
-                throw new ValueAmbiguity({ kind: 'ATTACHMENT', fieldId: field.id, fieldName: field.name, input: item, reason: '附件项缺少 optionId/content，或 type 不是 file', resolution: '固定格式 {"optionId":"上传返回的file_id","content":"文件名","type":"file"}' });
+            if (!optionId || !content) {
+                throw new ValueAmbiguity({ kind: 'ATTACHMENT', fieldId: field.id, fieldName: field.name, input: item, reason: '附件项缺少 optionId 或 content', resolution: '每项形如 {"optionId":"附件ID","content":"文件名","type":"文件类型"}；optionId 必须是附件自己的 ID，不要拿文件名或其它字符串顶替' });
             }
-            options.push({ optionId, content, type: 'file' });
+            // `type` **按原样透传**（图片是 image、普通文件是 file）。早先这里硬编码成 'file'，
+            // 会把图片附件写成错误的类型；历史数据里没有 type 时才退回 'file'。
+            options.push({ optionId, content, type: String(item.type ?? '').trim() || 'file' });
         }
         assertMultiplicity(field, options);
         detail.dataOptions = options;
@@ -2150,30 +2098,16 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 options.push({ optionId: String(item.id), content: String(item.name ?? item.content ?? item.id) });
                 continue;
             }
-            const keyword = String(item).trim();
+            const raw = String(item).trim();
             const rowIndex = String((row && row.dataIndex) ?? '0');
-            const lookupKey = `${field.id}_${rowIndex}_${keyword}`;
-            const candidates = mappings[lookupKey] || [];
-            const exact = candidates.filter((c) => c.name.toLowerCase() === keyword.toLowerCase());
-            const selected = exact.length === 1 ? exact : candidates;
-            if (selected.length !== 1) {
-                // 未命中时带上候选澄清清单（该浏览控件首页合法取值）；一个候选都没有时如实给空数组，
-                // 由文档要求模型"一次明确告知用户并请其给出准确名称"，禁止换相近词反复 prepare。
-                const hints = selected.length ? selected : (browserHints[lookupKey] || []);
-                throw new ValueAmbiguity({
-                    kind: 'BROWSER',
-                    fieldId: field.id,
-                    fieldName: field.name,
-                    input: keyword,
-                    reason: selected.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
-                    candidates: hints,
-                    candidatesAvailable: hints.length > 0,
-                    resolution: hints.length
-                        ? '从 candidates 里挑出用户确认的那个，按 {"id":"候选id","name":"候选名称"} 重新 prepare。'
-                        : '将该值改为 {"id":"候选id","name":"候选名称"} 后重新 prepare。',
-                });
-            }
-            options.push({ optionId: selected[0].id, content: selected[0].name });
+            // 候选两个来源：nameToId（getRelateData）→ mapped，该控件自己的 complete 接口 → completed。
+            // 两者**不做并集**（见 resolveBrowserAliases 的说明）。
+            const lookup = (term) => {
+                const key = `${field.id}_${rowIndex}_${term}`;
+                return { mapped: mappings[key] || [], completed: browserHints[key] || [] };
+            };
+            const picked = resolveBrowserAliases(field, raw, lookup);
+            options.push({ optionId: picked.id, content: picked.name });
         }
         assertMultiplicity(field, options);
         detail.dataOptions = options;
@@ -2190,7 +2124,17 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
             const keyword = String(item).trim();
             const matches = choices.filter((c) => String(c.id) === keyword || String(c.name ?? '').toLowerCase() === keyword.toLowerCase());
             if (matches.length !== 1) {
-                throw new ValueAmbiguity({ kind: 'OPTION', fieldId: field.id, fieldName: field.name, input: keyword, reason: matches.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND', candidates: matches || choices, resolution: '将该值改为 {"id":"选项id","name":"选项名称"} 后重新 prepare。' });
+                throw new ValueAmbiguity({
+                    kind: 'OPTION',
+                    fieldId: field.id,
+                    fieldName: field.name,
+                    input: keyword,
+                    reason: matches.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
+                    candidates: matches || choices,
+                    resolution: matches.length
+                        ? '把 candidates 原样交给用户确认；用户选定后由你取该项的 id / name 拼出 {"id":…,"name":…} 重发同一条命令（不要让用户提供 ID）。'
+                        : '该值在系统里没有匹配。请让用户给出该选项的完整名称，或其它可用于检索的关键词（不要向用户索取 ID）。',
+                });
             }
             selectedOptions.push({ optionId: matches[0].id, content: matches[0].name });
         }
@@ -2260,7 +2204,9 @@ async function preResolveEmployeeScopeEntries(env, entries) {
                     input: content,
                     reason: selected.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
                     candidates: selected.map((c) => ({ id: c.id, name: c.name })),
-                    resolution: `将该值改为 {"optionId":"候选id","content":"候选名称","type":"${scopeType}"} 后重新 prepare。`,
+                    resolution: selected.length
+                        ? `把 candidates 原样交给用户确认；用户选定后由你取该项的 id / name 拼出 {"optionId":…,"content":…,"type":"${scopeType}"} 重发同一条命令（不要让用户提供 ID）。`
+                        : '该名称在系统里没有匹配。请让用户给出该对象的完整名称，或其它可用于检索的关键词（不要向用户索取 ID）。',
                 };
                 break;
             }
@@ -2280,20 +2226,21 @@ async function preResolveEmployeeScopeEntries(env, entries) {
     }
     return failures;
 }
+/** 浏览控件候选查询的并发上限（对齐 `read.ts` 摘要补全的口径，避免大表单瞬时打爆对端）。 */
+const BROWSER_HINT_MAX_WORKERS = 5;
 /**
- * 浏览按钮字段「名称→ID 未命中」时的候选澄清（V12.1.22 定稿）。
+ * 浏览按钮字段「名称→ID 未命中」时的候选查询（V12.1.22 起，V12.1.58 改口径）。
  *
- * 名称→ID 走的是 `nameToId`（`/api/ai/chat/fieldMapping/getRelateData`），它**一个关键词只回一个
- * "最佳匹配"**，未命中时给不出任何候选 —— 于是 `ambiguities[].candidates` 只能是空数组，模型只能
- * 自己换相近词瞎猜（2026-09-16「费用类型=手机话费」实证：模型猜了"手机费"，最后干脆把字段删了）。
- * 同文件里 **select 分支** `candidates: matches || choices` 是会回退给出**该字段全部可选项**的，
- * 浏览按钮这一支缺了这个兜底。
+ * 控件自带浏览接口时的**唯一**候选来源（与人员范围同一套协议）：
+ * `POST /api/{browserModule}/common/browser/complete/{browserType}`，服务端按关键词过滤出的列表。
+ * 是否走这一路只取决于**控件有没有 `browserModule`+`browserType`**（见 `resolveEntryValues`），
+ * 有则**完全不再走** `nameToId`（`/api/ai/chat/fieldMapping/getRelateData`）——它一个关键词只回
+ * 一条"最佳匹配"，模糊结果既给不出候选清单，又会被误当字面命中。两者的选择是**二选一**，不是并集。
  *
- * 这里改用字段自带的浏览接口（与人员范围同一套协议）
- * `POST /api/{browserModule}/common/browser/complete/{browserType}`：
- *   ① 先按关键词查一次（该接口与 nameToId 不是同一实现，可能命中 nameToId 命不中的值）；
- *   ② 仍为空 → **再用空关键词**查一次，把该浏览控件首页的合法取值当候选返回，让模型/用户有据可依。
- * 只对**真的没命中**的关键词发请求，命中路径零额外开销。
+ * **不再用空关键词枚举该控件首页**（V12.1.22 那版会这么做）：真机「会议室=4楼」实证——关键词
+ * 0 命中时列出的 10 条其实是**未过滤的默认首页**，与关键词毫无关系，模型会把它当成"按关键词
+ * 匹配出来的候选"转述给用户 ⇒ **误导选择**。命不中就如实给空数组，由文档要求模型"一次明确
+ * 告知用户并请其给出准确名称"。
  */
 async function browserFieldCandidates(env, field, keyword) {
     const module = String(field?.browserModule ?? '').trim();
@@ -2338,12 +2285,9 @@ async function browserFieldCandidates(env, field, keyword) {
         return out;
     };
     const kw = String(keyword ?? '').trim();
-    const byKeyword = kw ? await fetchOnce(kw) : [];
-    if (byKeyword.length)
-        return byKeyword;
-    // 关键词查不到 → 取该浏览控件的合法取值清单（空关键词枚举首页）
-    const all = await fetchOnce('');
-    return all.filter((c) => c.name.toLowerCase() !== kw.toLowerCase());
+    if (!kw)
+        return [];
+    return fetchOnce(kw);
 }
 async function resolveEntryValues(env, entries, formId) {
     // 人员范围先做名称→ID（它不走 nameToId，也不该被当成普通浏览按钮字段）
@@ -2365,25 +2309,39 @@ async function resolveEntryValues(env, entries, formId) {
         for (const item of listValues(entry.value)) {
             if (item && typeof item === 'object' && (item.id || item.optionId))
                 continue;
-            const keyword = String(item).trim();
-            if (!keyword)
-                continue;
-            const lookupKey = `${field.id}_${rowIndex}_${keyword}`;
-            if (seenLookups.has(lookupKey))
+            const raw = String(item).trim();
+            if (!raw)
                 continue;
-            seenLookups.add(lookupKey);
-            lookupSpecs.set(lookupKey, { field, keyword });
-            fieldDatas.push({
-                fieldId: String(field.id),
-                componentKey: field.componentKey || '',
-                fieldValue: keyword,
-                rowIndex,
-                operateType: 'add',
-                isDetail,
-                subFormId: String(field.subFormId || '0'),
-                browserModule: field.browserModule || '',
-                browserType: field.browserType || '',
-            });
+            // 一个格子可写多个「说法」（逗号分隔）：**整串与各说法一起登记**——这样"整串优先"要用的
+            // 整串候选、以及各说法各自的候选，都在同一批里拿到（nameToId 一把批量发，未命中的再并行补）。
+            const aliases = splitValueAliases(raw);
+            const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+            // 候选来源二选一：控件自带 `browserModule`+`browserType` ⇒ 只走 complete（下一步补查），
+            // **不进 nameToId 批次**；否则只走 nameToId。这样池子里永远只有一个来源，不会互相污染。
+            const hasBrowserChannel = Boolean(field.browserModule && field.browserType);
+            for (const term of terms) {
+                // 显式 ID（`名称(ID)`，括号内纯数字）不必查名：resolveBrowserAliases 会直接采用它。
+                if (parseNameWithId(term).id)
+                    continue;
+                const lookupKey = `${field.id}_${rowIndex}_${term}`;
+                if (seenLookups.has(lookupKey))
+                    continue;
+                seenLookups.add(lookupKey);
+                lookupSpecs.set(lookupKey, { field, keyword: term });
+                if (hasBrowserChannel)
+                    continue;
+                fieldDatas.push({
+                    fieldId: String(field.id),
+                    componentKey: field.componentKey || '',
+                    fieldValue: term,
+                    rowIndex,
+                    operateType: 'add',
+                    isDetail,
+                    subFormId: String(field.subFormId || '0'),
+                    browserModule: field.browserModule || '',
+                    browserType: field.browserType || '',
+                });
+            }
         }
     }
     const mappings = {};
@@ -2407,17 +2365,28 @@ async function resolveEntryValues(env, entries, formId) {
             }
         }
     }
-    // 名称→ID 未命中的浏览按钮：补一次候选澄清（只对真的没命中的关键词发请求）。
-    // 有了候选清单，模型的 `ambiguities[].resolution` 才有据可依（把合法取值列给用户选），
+    // 自带浏览接口的控件：按关键词查一次 complete 拿候选清单（这是该类控件的**唯一**候选来源）。
+    // 有了候选清单，模型的 `ambiguities[].resolution` 才有据可依（把真实命中列给用户选），
     // 而不是拿到空数组后自己换相近词硬猜（见 browserFieldCandidates 的说明）。
     const browserHints = {};
+    const pendingHints = [];
     for (const [key, spec] of lookupSpecs) {
-        if (mappings[key] && mappings[key].length)
-            continue;
         if (!spec.field.browserModule || !spec.field.browserType)
             continue;
-        browserHints[key] = await browserFieldCandidates(env, spec.field, spec.keyword);
-    }
+        pendingHints.push([key, spec]);
+    }
+    // 「整串 + 各说法」的候选查询**并行**发出（上限 BROWSER_HINT_MAX_WORKERS）：
+    // 串行会让一个格子写多个说法时白等好几轮往返。
+    let hintCursor = 0;
+    const hintWorker = async () => {
+        while (hintCursor < pendingHints.length) {
+            const [key, spec] = pendingHints[hintCursor];
+            hintCursor += 1;
+            browserHints[key] = await browserFieldCandidates(env, spec.field, spec.keyword);
+        }
+    };
+    const hintWorkers = Math.max(1, Math.min(pendingHints.length, BROWSER_HINT_MAX_WORKERS));
+    await Promise.all(Array.from({ length: hintWorkers }, () => hintWorker()));
     const details = [];
     const ambiguities = [];
     const preview = [];
@@ -3333,87 +3302,12 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
 // ---------------------------------------------------------------------------
 // createRequest（合并原 createPrepare + createApply）
 // ---------------------------------------------------------------------------
-/**
- * 把 preview 里的字段值渲染成人类可读文本（写进记忆偏好用）。
- *
- * `preview[].value` 的形态随字段类型而变：文本是字符串、选项是字符串、浏览/人员/部门是
- * `{id,name}`（或数组）。这里只取可读的名字部分，避免把 `[object Object]` 写进记忆。
- */
-function preferenceTextOf(value) {
-    if (value === undefined || value === null)
-        return '';
-    if (Array.isArray(value)) {
-        return value
-            .map((item) => String((item && typeof item === 'object') ? (item.name ?? item.content ?? '') : item).trim())
-            .filter(Boolean)
-            .join('、');
-    }
-    if (typeof value === 'object')
-        return '';
-    return String(value).trim();
-}
-/**
- * 保存成功后把「本次必填字段的取值」沉淀为该工作流的发起偏好（`agentMemoryExtract`）。
- *
- * **放在 CLI 内部做**（模型无感）：这是「这次必填项填了什么」这类确定性事实，不是需要语义抽取的
- * 自由文本——由命令自己记下来最可靠，也省掉「模型任务结束时再补一次 memoryExtract」这一轮往返。
- * best-effort：失败只返回 `false`，绝不影响发起结果。
- *
- * 2026-09-23：**静默化** —— 调用方**不再把返回值写进任何输出字段**（原先回 `memorySaved`）。
- * 返回值仍是 `boolean`，仅保留给单元测试/内部判断用；路由层不得再把它暴露给模型。
- */
-async function saveLaunchPreferences(workflow, requiredFieldIds, preview, env) {
-    const pairs = [];
-    const seen = new Set();
-    for (const item of preview || []) {
-        const fieldId = String(item?.fieldId ?? '').trim();
-        if (!fieldId || !requiredFieldIds.has(fieldId) || seen.has(fieldId))
-            continue;
-        const text = preferenceTextOf(item.value);
-        if (!text)
-            continue;
-        seen.add(fieldId);
-        pairs.push(`${String(item.fieldName ?? fieldId).trim()}=${text}`);
-    }
-    if (!pairs.length)
-        return false;
-    const workflowId = String(workflow.id ?? '').trim();
-    const workflowName = String(workflow.name ?? '').trim();
-    try {
-        const response = await env.host.workflowRequest({
-            method: 'POST',
-            path: WORKFLOW_ENDPOINTS.MEMORY_EXTRACT,
-            operation: 'workflow.createRequest',
-            body: {
-                chatParams: {
-                    // appid 必须始终携带（缺省时记忆接口判为无效应用、静默不保存）
-                    appid: resolveMemoryAppId(),
-                    dynamicContextParams: { ...(workflowId ? { workflowId } : {}) },
-                },
-                // 末尾补 remember 保存触发信号词（与 workflow.memoryExtract 同口径）
-                aiMsgEntityList: [
-                    { msgRole: 'user', msgValue: `记住：发起「${workflowName || workflowId}」流程时，这些必填项的常用值为 ${pairs.join('；')}。` },
-                    { msgRole: 'user', msgValue: 'remember' },
-                ],
-            },
-        });
-        // 记忆接口业务标志是 status/fail（不是 success）；只在明确失败时判未保存
-        const body = (response && typeof response === 'object' ? response : {});
-        if (body.saved === false || body.success === false || body.status === false || body.fail === true)
-            return false;
-        return body.saved === true || body.success === true || body.status === true || body.code === 200 || body.fail === false;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * `workflow.createRequest` —— **一条命令**完成「字段解析 → 联动 → 必填校验 → 保存 → 发起」。
  *
  * 模型只需按用户意图把字段填好直接调用，**不需要自己判断必填是否缺失**：
  * - `action=submit` 且仍有必填缺失 → **一个写请求都不发**，把全部缺失项一次交回（`NEEDS_INPUT`）；
- * - `action=draft` → 直接创建草稿，缺失项仅作提醒随结果返回（**含联动后才变成必填的字段**）；
- * - 成功保存后，CLI **内部**把必填字段的本次取值沉淀为该工作流的偏好（模型无感）。
+ * - `action=draft` → 直接创建草稿，缺失项仅作提醒随结果返回（**含联动后才变成必填的字段**）。
  *
  * 句柄消费时机（关键）：**只在真正要发写入请求之前**消费。缺必填 / 需澄清这类「还没写」的
  * 返回**不消费**句柄，于是模型补齐字段后可以带**同一个 context** 重发，不必回头重跑 createForm；
@@ -3495,6 +3389,26 @@ async function commandCreateRequest(args, env) {
             linkageRequiredIds.add(String(fieldId));
     }
     const missingAll = [...missing, ...systemMissing];
+    /**
+     * 历史参考值（V12.1.77）：取数已在 `createForm` 做完，这里**只从句柄里的缓存筛**，不再联网。
+     *
+     * 只筛「**这次新出现**的必填字段」——即 `createForm` 当时还没被判成必填、模型因此没见过的那些
+     * （绝大多数是联动命中后才变成必填的字段）。`createForm` 已经给过历史值的字段不再重复返回：
+     * 那些值模型本来就拿到了，重复给只是白占上下文。
+     *
+     * `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))
+            continue;
+        newMissingFieldIds.add(fieldId);
+    }
+    const historyRequestData = filterHistoryRequestData(context.historyCache, newMissingFieldIds);
     if (valueAmbiguities.length) {
         return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_CONFIRMATION',
@@ -3506,6 +3420,7 @@ async function commandCreateRequest(args, env) {
             resolvedValues: preview,
             ambiguities: valueAmbiguities,
             missingFields: missingAll,
+            historyRequestData,
             linkageResult,
             ...folderPayload,
         });
@@ -3518,6 +3433,7 @@ async function commandCreateRequest(args, env) {
             message: '缺少必填字段，本次未发起流程。请把下面这些字段一次问齐后，带同一 context 重发 action=submit。',
             resolvedValues: preview,
             missingFields: missingAll,
+            historyRequestData,
             linkageResult,
             ...folderPayload,
         });
@@ -3588,18 +3504,7 @@ async function commandCreateRequest(args, env) {
         }
         throw error;
     }
-    const submitIntent = action === 'submit';
-    let verification = {};
-    let needConfirm = false;
-    if (submitIntent) {
-        verification = await runCreateNodeFieldVerification(env, context);
-        const reminders = verification.reminders || [];
-        needConfirm = verification.enabled
-            ? (Boolean(reminders.length && verification.noPassPrompt === 1) || (!reminders.length && verification.passPopUpPrompt === 1))
-            : false;
-    }
-    const createSrc = (submitIntent && !verification.blocked && !(needConfirm && args.verificationConfirmed !== true)) ? 'submit' : 'save';
-    // 提交时字段联动（EVENT_SUBMIT_OR_AGREE）
+    // 提交时字段联动（EVENT_SUBMIT_OR_AGREE）——要在 create 之前跑完（可能改 dataDetails/必填）
     if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
         const submitDetails = prepared.dataDetails || [];
         const submitEntries = _entriesFromDefaults(submitDetails);
@@ -3614,33 +3519,62 @@ async function commandCreateRequest(args, env) {
             }
         }
     }
+    // ── ① 先建实例：**一律 src='save'** ────────────────────────────────────────
+    // 「创建」与「要不要提交」彻底解耦，与真机同序（2026-09-28 HAR：`flow/create{src:'save'}` →
+    // 节点校验 → `flow/submit` 三次独立调用）。这样只要这一步成功，流程单据**就已经存在**；
+    // 之后任何环节出问题都不会再出现"发起失败且查无此单"。
+    // 旧实现把 src 与节点校验结果绑死在同一次 create 上，校验一报错就**连实例都没建**——那正是
+    // "草稿查不到"的根因。
     let created;
     try {
         const createResponse = await env.host.workflowRequest({
             method: 'POST',
             path: FORM_ENDPOINTS.create,
             query: AJAX_QUERY,
-            body: buildCreateBody(context, resolvePrepared(context, prepared), saveData, createSrc),
+            body: buildCreateBody(context, resolvePrepared(context, prepared), saveData, 'save'),
             operation: 'workflow.createRequest',
         });
         // parseCreateResponse 需读外层 status/code 并向下遍历 data/result，必须传原始响应
         created = parseCreateResponse(createResponse, context.runtime.request_id);
-        if (created.outcome === 'created') {
-            // flow/create 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
-            // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
-            await env.continuation
-                .markStage(token, 'committed', { requestId: context.runtime.request_id })
-                .catch(() => undefined);
-        }
-        // outcome === 'rejected' 时**不**标 committed：服务端并没有给"成功回执"，
-        // 标了会让后续重放报出"上一次已成功"的假消息。结果照常由 settle() 收尾。
     }
     catch (error) {
         if (isNetworkError(error)) {
-            throw workflowPartialError('saveFormData 已成功，但 flow/create 结果失败或不确定；禁止自动重试。', { stage: 'flow/create', ...saveData }, { stage: 'flow/create' });
+            throw workflowPartialError('saveFormData 已成功，但 flow/create 结果失败或不确定。请把该结果如实告知用户并停下，不要自行重试、也不要改用其它命令去推断。', { stage: 'flow/create', ...saveData }, { stage: 'flow/create' });
         }
         throw error;
     }
+    if (created.outcome === 'rejected') {
+        // 实例**没建出来**（服务端在创建时就明确拒绝并给了原因）。此时什么都不存在，如实报失败即可；
+        // 绝不返回"已创建"字样的信封——那会让用户与模型都以为有草稿可查。
+        throw workflowApiError('create_rejected', `流程创建被服务端拒绝，本次未生成流程单据。原因：${created.reason}。`
+            + '请把该结果如实告知用户，不要自行重试或改用其它命令推断。', { stage: 'flow/create', details: { reason: created.reason, resultType: created.resultType } });
+    }
+    // ── ② 实例已在：提交时重载提交页上下文（view 页鉴权 + 节点校验开关）→ 校验 → 提交 ──
+    const submitIntent = action === 'submit';
+    let verification = {};
+    let needConfirm = false;
+    let submitOutcome = null;
+    if (submitIntent) {
+        const submitContext = await loadCreateSubmitContext(env, context, prepared.requestLevel);
+        verification = await runCreateNodeFieldVerification(env, context, {
+            openVerifictionNodeField: submitContext.openVerifictionNodeField,
+            popUpPromptVerifictionNodeField: submitContext.popUpPromptVerifictionNodeField,
+            requestLevel: submitContext.requestLevel,
+        });
+        const reminders = verification.reminders || [];
+        needConfirm = verification.enabled
+            ? (Boolean(reminders.length && verification.noPassPrompt === 1) || (!reminders.length && verification.passPopUpPrompt === 1))
+            : false;
+        // 只有"该提交"才提交：被校验拦下、或需要用户确认而未确认时，**停在草稿**。
+        if (!verification.blocked && !(needConfirm && args.verificationConfirmed !== true)) {
+            submitOutcome = await submitCreatedRequest(env, context, prepared, submitContext);
+        }
+    }
+    // 整条链路（创建 + 可能有的提交）都收尾了才推进到 committed：此后再被中止，重放可报幂等成功。
+    // 若提前标（旧实现在 create 一成功就标），"只建了草稿、提交没成"会被重放报成"上一次已成功"。
+    await env.continuation
+        .markStage(token, 'committed', { requestId: context.runtime.request_id })
+        .catch(() => undefined);
     const requestId = context.runtime.request_id;
     const baseUrl = (await getSessionContext(env)).baseUrl;
     const result = {
@@ -3650,8 +3584,8 @@ async function commandCreateRequest(args, env) {
         requestId,
         requestName: prepared.requestName,
         requestId_alt: requestId,
-        requestMark: (created.outcome === 'created' && created.requestMark) || null,
-        requestName_alt: (created.outcome === 'created' && created.requestName) || prepared.requestName,
+        requestMark: created.requestMark || null,
+        requestName_alt: created.requestName || prepared.requestName,
         workflow: context.workflow,
         url: `${baseUrl}/sp/workflow/flowpage/view/${requestId}?operResultType=SUCCESS_RELOAD_CURRENT_PAGE&userSpecifiedNodeId=0&autoMaxDisplay=0`,
         linkageResult,
@@ -3664,18 +3598,7 @@ async function commandCreateRequest(args, env) {
         previewDetails: prepared.previewDetails,
     };
     if (submitIntent) {
-        if (created.outcome === 'rejected' && createSrc === 'submit') {
-            // 服务端明确拒绝提交，但**表单数据已落库、流程以草稿形态存在**（真机实测：被拒后该
-            // requestId 在 workflow.detail 里查得到，flowStatus=草稿）。故按"完成 + 提交结果失败"
-            // 返回，而不是抛错——抛错会让模型以为"什么都没做成"而重发，一路堆积重复草稿。
-            // 所有"成功时会给的创建信息"这里一个都不少，只是提交结果是失败。
-            result.status = 'CREATED_SUBMIT_FAILED';
-            result.message = `流程已创建为草稿，但提交被服务端拒绝（未进入审批）。原因：${created.reason}`;
-            result.submitResult = 'failed';
-            result.submitFailReason = created.reason;
-            result.verification = verification;
-        }
-        else if (verification.blocked) {
+        if (verification.blocked) {
             result.message = '流程已创建，但因节点字段校验未通过未提交审批，请调整后重新提交。';
             result.verification = verification;
         }
@@ -3685,6 +3608,16 @@ async function commandCreateRequest(args, env) {
             result.verification = verification;
             result.nodeId = context.runtime.node_id;
         }
+        else if (!submitOutcome || !submitOutcome.ok) {
+            // 提交没成功，但**流程单据已经建出来了**（第 ① 步已成功）。如实回报"创建成功 + 提交失败"，
+            // 不把它复述成整条命令失败，也**不提示模型去自行判断/重发**——用户看到的就是真实状态。
+            const reason = (submitOutcome && submitOutcome.reason) || '服务端未给出原因';
+            result.status = 'CREATED_SUBMIT_FAILED';
+            result.message = `流程已创建为草稿，但提交未成功（未进入审批）。原因：${reason}`;
+            result.submitResult = 'failed';
+            result.submitFailReason = reason;
+            result.verification = verification;
+        }
         else {
             result.status = 'CREATED_SUBMITTED';
             result.message = '流程已发起并提交审批。';
@@ -3704,27 +3637,6 @@ async function commandCreateRequest(args, env) {
                     : '。');
         }
     }
-    // 非"本次真发起提交"的路径（action=draft，或被节点校验拦下、未真正提交）里 flow/create 也被拒：
-    // 不改这些分支的状态语义（它们本就描述"未提交审批"），但把服务端给的原因附上，避免信息静默丢失。
-    if (created.outcome === 'rejected' && !(submitIntent && createSrc === 'submit')) {
-        result.createRejectedReason = created.reason;
-        result.message = `${result.message}（服务端在创建时返回：${created.reason}）`;
-    }
-    // 必填字段的本次取值 → 该工作流的发起偏好（CLI 内部完成、**静默**，见下方调用点注释）
-    const requiredFieldIds = new Set();
-    for (const field of fields) {
-        if (field.readOnly || field.disableEdit)
-            continue;
-        if (field.required)
-            requiredFieldIds.add(String(field.id ?? ''));
-    }
-    for (const fieldId of linkageRequiredIds)
-        requiredFieldIds.add(fieldId);
-    // 2026-09-23 用户裁定：必填偏好的沉淀必须**静默** —— 只调接口，**不写进任何返回字段**
-    // （此前会回 `memorySaved`，等于把这个内部副作用暴露给模型：可被复述、可被据以推断"已经记过了"）。
-    // 它的用途只是「后续发起同类流程时，可直接用历史偏好补齐必填项」——减少对用户的打扰、提升发起速度，
-    // 属于纯 CLI 内部行为，因此**输出里不得出现任何痕迹**。best-effort：失败也不影响发起结果。
-    await saveLaunchPreferences(context.workflow || {}, requiredFieldIds, preview, env);
     return workflowSuccess('workflow.createRequest', result);
 }
 function formatRemark(value) {
@@ -3835,6 +3747,104 @@ function buildCreateBody(context, prepared, saved, src) {
         clientType: 0,
     };
 }
+/**
+ * `flow/submit` 的请求体（真机逐字段照抄：2026-09-28 HAR `POST /api/workflow/core/flow/submit?requestId=<id>`）。
+ *
+ * 与 `buildCreateBody` 的差异，正是"创建"与"提交"的差异：
+ *   - 不带 `requestName`/`dataId`/`recordId`/`saveFormTime`（数据已在库，不必再随包传）；
+ *   - `isCreate: false`，`pageKey` 是 **view 页**的 `view_<requestId>_<ts>`；
+ *   - 鉴权用**创建成功后重载**拿到的 view 页那一份（见 `loadCreateSubmitContext`）；
+ *   - 多带 `operResultType`/`userSpecifiedNodeId`/`needAutoOpen`/`autoMaxDisplay`/`testParam`/
+ *     `seconedSubmit`（字段名本来就少一个 n，照抄不改）。
+ */
+function buildSubmitBody(context, prepared, view) {
+    const runtime = context.runtime;
+    const requestId = String(runtime.request_id ?? '');
+    const remark = formatRemark(prepared.remark);
+    return {
+        operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE',
+        userSpecifiedNodeId: '0',
+        needAutoOpen: '1',
+        autoMaxDisplay: '0',
+        isCreate: false,
+        requestId,
+        apiModule: 'workflow',
+        identityId: runtime.identity_id,
+        identityType: runtime.identity_type,
+        workflowId: context.workflow.id,
+        userCurrentNodeId: runtime.node_id,
+        isAgent: false,
+        beAgentId: '0',
+        fixedNodeId: runtime.node_id,
+        authStr: view.authStr,
+        authSignatureStr: view.authSignatureStr,
+        isTest: false,
+        pageKey: `view_${requestId}_${Date.now()}`,
+        requestLevel: String(prepared.requestLevel ?? '0').trim(),
+        secLevel: String(prepared.secLevel ?? '0').trim(),
+        secValidity: '',
+        needWfBack: true,
+        sameOperateId: null,
+        customBtnId: null,
+        confirmSecondSubmit: false,
+        selectFlowParam: null,
+        freeChoiceNodeIds: null,
+        nodeAddOperators: null,
+        testParam: {},
+        src: 'submit',
+        voteSubmit: false,
+        seconedSubmit: false,
+        remark,
+        attachments: [],
+        fileData: [],
+        locationData: {},
+        comment: {
+            relevanceList: [],
+            imAtContent: remark !== '_weaverMte_' ? remark : '',
+            originContent: remark !== '_weaverMte_' ? remark : '',
+            atLinkList: [],
+            content: remark,
+        },
+        quoteData: [],
+        fullTextAnnotationData: [],
+        signatureData: { signatureImgId: '' },
+        userSignatureData: { signatureImgId: '' },
+        sealId: null,
+        unNeedVerifyPrivacyAgreement: 1,
+        clientType: 0,
+    };
+}
+/**
+ * 提交结果的成败判定——信号口径见 `isSubmitRejected`（**与创建侧不同**，不可复用 `isCreateRejected`）。
+ * 失败原因复用 `pickCreateRejectReason` 的"越具体越优先"取法。
+ */
+function parseSubmitResponse(response) {
+    if (!response || typeof response !== 'object')
+        return { ok: false, reason: '服务端未返回可识别的响应' };
+    const record = response;
+    if (isSubmitRejected(record))
+        return { ok: false, reason: pickCreateRejectReason(record) };
+    return { ok: true, reason: '' };
+}
+/**
+ * `flow/submit` 的**明确拒绝**判定——**不能照搬 `isCreateRejected`**。
+ *
+ * 那套口径里的 `flowIsCreateSuccess === false` 是**创建语义**：该字段的含义是「本次调用有没有
+ * 创建流程实例」。`flow/create` 成功时它是 `true`，而在 `flow/submit` 的**成功**响应里天然是
+ * `false`（2026-09-28 真机抓包：`status:true`、`resultType:"SUCCESS_READ_PATH_CONFIG"`、
+ * `isDraft:false`、`flowIsCreateSuccess:false`，流程实际已进入审批）。照搬 ⇒ **每次提交都被判成
+ * 失败**（V12.1.59~61 的 `CREATED_SUBMIT_FAILED` 误报，且"原因"会取到一句写着"流程提交成功"的
+ * 壳文案），进而诱导模型/用户重复提交。
+ *
+ * 因此只保留在**提交**响应里语义成立的三条信号：`status` / `resultType` 才是这个接口的成败口径。
+ */
+function isSubmitRejected(response) {
+    if (response.fail === true)
+        return true;
+    if (response.status === false)
+        return true;
+    return String(response.resultType ?? '').trim().toUpperCase().startsWith('FAIL');
+}
 function parseSaveResponse(response) {
     const data = responseData(response);
     if (!data || typeof data !== 'object')
@@ -3945,7 +3955,112 @@ function parseCreateResponse(response, expectedRequestId) {
         requestName: firstText('requestName', 'requestname'),
     };
 }
-async function runCreateNodeFieldVerification(env, context) {
+/**
+ * 流程实例创建**之后**重载"提交页上下文"（真机同序：`flow/create` 成功后页面整个重载）。
+ *
+ * 一次拿齐两样东西：
+ *   - `loadBaseParam?isCreate=0&requestId=<id>` → `data.commonParam.authStr`/`authSignatureStr`：
+ *     **view 页**鉴权（`flow/submit` 必须用它；沿用创建页的 authStr 服务端会拒）；
+ *   - `loadMinorInfo?isCreate=0&requestId=<id>` → `data.params.openVerifictionNodeField` +
+ *     `popUpPromptVerifictionNodeField`：节点字段校验的两级开关。
+ *
+ * 两请求**并行 best-effort**：任一失败都不阻断（鉴权缺失时提交由服务端拒绝，届时按"提交失败"
+ * 如实回报即可；开关缺失按"未开启节点字段校验"处理，宁少校验不误拦）。
+ */
+async function loadCreateSubmitContext(env, context, requestLevel) {
+    const runtime = context.runtime;
+    const requestId = String(runtime.request_id ?? '');
+    const query = { isCreate: '0', requestId };
+    const body = {
+        operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE',
+        userSpecifiedNodeId: '0',
+        needAutoOpen: '1',
+        autoMaxDisplay: '0',
+        isCreate: 0,
+        requestId,
+    };
+    const [base, minor] = await Promise.all([
+        requestJson(env, 'POST', FORM_ENDPOINTS.loadBase, query, body).catch(() => null),
+        requestJson(env, 'POST', FORM_ENDPOINTS.loadMinor, query, body).catch(() => null),
+    ]);
+    const commonParam = (base && typeof base === 'object' && typeof base.commonParam === 'object')
+        ? base.commonParam
+        : {};
+    const params = (minor && typeof minor === 'object' && typeof minor.params === 'object')
+        ? minor.params
+        : {};
+    const pv = (params.popUpPromptVerifictionNodeField && typeof params.popUpPromptVerifictionNodeField === 'object')
+        ? params.popUpPromptVerifictionNodeField
+        : {};
+    return {
+        authStr: String(commonParam.authStr ?? runtime.auth_str ?? ''),
+        authSignatureStr: String(commonParam.authSignatureStr ?? runtime.auth_signature ?? ''),
+        openVerifictionNodeField: asBool(params.openVerifictionNodeField, false),
+        popUpPromptVerifictionNodeField: pv,
+        requestLevel: String(requestLevel ?? '0').trim(),
+    };
+}
+/**
+ * 提交**已创建**的流程（真机同序：`flow/create{src:'save'}` 之后单独调 `flow/submit`）。
+ *
+ * **不抛错、只返回成败**：流程单据此刻已经存在，提交失败只是"提交没成"，把整条命令报成失败会
+ * 让"创建成功"这个事实丢失（那正是 A.100 里"发起失败且查无此单"的反面）。
+ * 连接中断同样按"提交结果不确定"如实回报；**认证错误照规则原样抛**，不降级成数据结论。
+ */
+async function submitCreatedRequest(env, context, prepared, view) {
+    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),
+            operation: 'workflow.createRequest',
+        });
+    }
+    catch (error) {
+        rethrowAuthOrNetwork(error);
+        return { ok: false, reason: '提交请求发送后连接中断，提交结果不确定' };
+    }
+    return parseSubmitResponse(response);
+}
+/**
+ * 节点字段校验的**第一跳**：只问服务端「要不要把校验结果展示给用户」。
+ *
+ * 请求体逐字段照真机：`identityId`/`requestName`/`requestLevelName` 固定空串，`cptSetList` 就是
+ * `loadMinorInfo` 原样给的那一份（**透传不加工**）。返回 `data` 是布尔——真 ⇒ 需要展示 ⇒ 才值得
+ * 去取详细规则集逐条算。
+ */
+async function verifyNodeFieldByList(env, context, switches) {
+    const runtime = context.runtime;
+    const data = await requestJson(env, 'POST', FORM_ENDPOINTS.verifyNodeFieldByList, AJAX_QUERY, {
+        requestId: String(runtime.request_id ?? ''),
+        nodeId: String(runtime.node_id ?? ''),
+        passPopUpPrompt: switches.passPopUpPrompt,
+        noPassPrompt: switches.noPassPrompt,
+        requestLevel: switches.requestLevel,
+        requestLevelName: '',
+        identityId: '',
+        requestName: '',
+        ruleRelation: switches.ruleRelation,
+        isTest: 0,
+        isMobile: false,
+        testUserId: String(runtime.employee_id ?? ''),
+        cptSetList: switches.cptSetList,
+    });
+    return data === true;
+}
+/**
+ * 节点字段校验（发起侧）。**三级门，顺序不可换**（2026-09-28 两份真机 HAR 实证）：
+ *   ① `openVerifictionNodeField` 为假 ⇒ 该流程没开节点字段校验，整段跳过；
+ *   ② `passPopUpPrompt`、`noPassPrompt` **不都为真** ⇒ 先调 `verifyNodeFieldByList`，用它的布尔
+ *      结果当"要不要展示"；为假 ⇒ 无需展示、整段跳过。**「会议申请」流程正是此路**（两个开关都是
+ *      false）：旧实现跳过这一跳直接去取规则集，被服务端以"系统错误"拒掉，且因为它在 `flow/create`
+ *      之前执行，连流程实例都没建出来；
+ *   ③ 需要展示 ⇒ 才取 `getConformanceSetByVerification` + `getRequestDataByRequestId` + 逐条
+ *      `verificationConditionRule`。「销售合同」流程（两个开关都是 true，规则 15 条）走此路。
+ */
+async function runCreateNodeFieldVerification(env, context, switches) {
     const runtime = context.runtime;
     const requestId = String(runtime.request_id ?? '').trim();
     const nodeId = String(runtime.node_id ?? '').trim();
@@ -3954,6 +4069,24 @@ async function runCreateNodeFieldVerification(env, context) {
         result.error = '缺少 requestId 或 nodeId，跳过节点字段校验';
         return result;
     }
+    if (!switches.openVerifictionNodeField)
+        return result;
+    const pv = (switches.popUpPromptVerifictionNodeField && typeof switches.popUpPromptVerifictionNodeField === 'object')
+        ? switches.popUpPromptVerifictionNodeField
+        : {};
+    const passPopUpPrompt = Number(pv.passPopUpPrompt ?? 0);
+    const noPassPrompt = Number(pv.noPassPrompt ?? 0);
+    if (!passPopUpPrompt || !noPassPrompt) {
+        const showDialog = await verifyNodeFieldByList(env, context, {
+            passPopUpPrompt,
+            noPassPrompt,
+            ruleRelation: Number(pv.ruleRelation ?? 0),
+            cptSetList: Array.isArray(pv.cptSetList) ? pv.cptSetList : [],
+            requestLevel: switches.requestLevel,
+        });
+        if (!showDialog)
+            return result;
+    }
     const baseUrl = (await getSessionContext(env)).baseUrl;
     const referer = `${baseUrl}/sp/workflow/flowpage/create/${context.workflow.id}?workflowId=${context.workflow.id}&isCreate=1`;
     const conf = await requestJson(env, 'GET', FORM_ENDPOINTS.conformanceSet, {
@@ -4218,7 +4351,12 @@ async function commandEditLoad(args, env) {
     const slimFields = [];
     const folderOptionValues = _mainValueMap(currentDetails);
     for (const field of fields) {
-        const item = { id: field.id, name: field.name, subFormId: field.subFormId, componentKey: field.componentKey };
+        // 同 createForm：`subFormId` 为空则省略该键（缺键＝主表字段）。
+        const slimSubFormId = String(field.subFormId ?? '');
+        const item = { id: field.id, name: field.name };
+        if (slimSubFormId)
+            item.subFormId = slimSubFormId;
+        item.componentKey = field.componentKey;
         if (field.required)
             item.required = true;
         for (const key of ['isBrowser', 'isSelect', 'isMultiple', 'browserType', 'browserModule']) {
@@ -4272,12 +4410,6 @@ async function commandEditLoad(args, env) {
             row.rowId = detail.rowId;
         currentValues.push(row);
     }
-    // 可写字段补偿索引（同 createForm，见 encodeWritableFieldsCompact）：只在 `fields`
-    // 被整体移出 stdout 时随输出。只保留确实在本次字段清单里的 id，保证每行都有真实字段名。
-    const slimFieldIdSet = new Set(slimFields.map((f) => String(f.id ?? '')));
-    const editWritableIds = [...new Set((context.editableIds || []).map((x) => String(x)))]
-        .filter((id) => slimFieldIdSet.has(id));
-    const writableFieldsCompact = encodeWritableFieldsCompact(editWritableIds, slimFields, SYSTEM_FIELD_KEYS);
     return workflowSuccess('workflow.editLoad', await compactFormOutput({
         status: 'EDIT_READY',
         contextId: token,
@@ -4289,7 +4421,7 @@ async function commandEditLoad(args, env) {
         currentValues,
         fields: slimFields,
         continuation: token,
-    }, env, 'last_edit_load.json', writableFieldsCompact));
+    }, env, 'last_edit_load.json'));
 }
 function buildEditLinkageParam(context, dataList, runDataList) {
     const runtime = context.runtime || {};
@@ -4301,7 +4433,7 @@ function buildEditLinkageParam(context, dataList, runDataList) {
         employeeId: context.employee_id || runtime.employee_id || '',
         customParam: {
             permissionType: Number(frame.permission_type ?? 1),
-            requestId: context.request_id,
+            requestId: context.requestId ?? context.request_id,
             workflowId: context.workflow.id,
             nodeId: runtime.node_id || '',
             dataSrc: 'NEW',
@@ -4416,7 +4548,7 @@ function buildEditSaveBody(context, prepared) {
         module: 'workflow',
         customParam: {
             isCreate: false,
-            requestId: context.request_id,
+            requestId: context.requestId ?? context.request_id,
             isTest: false,
             secretLevel: '0',
             secretLevelValidity: '',
@@ -4496,12 +4628,12 @@ async function commandEditSave(args, env) {
     // saveFormData 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
     // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
     await env.continuation
-        .markStage(token, 'committed', { requestId: context.request_id })
+        .markStage(token, 'committed', { requestId: context.requestId ?? context.request_id })
         .catch(() => undefined);
     return workflowSuccess('workflow.editSave', {
         status: 'EDIT_SAVED',
         contextId: token,
-        requestId: context.request_id,
+        requestId: context.requestId ?? context.request_id,
         workflow: context.workflow,
         message: '流程表单内容已保存（仅保存表单字段，未提交流程）。',
         saved: { data_id: String(saveData.id ?? ''), updateTimeStamp: newTimeStamp, recordId: String(saveData.recordId ?? '') },
@@ -4547,7 +4679,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 + 该工作流的发起偏好 + 本表单必填字段的历史参考值（不落业务数据）',
     capability: 'create',
     risk: 'read',
     requiresConfirmation: false,
@@ -4555,7 +4687,7 @@ const workflowCreateForm = {
         workflow: {
             type: 'array',
             items: { type: 'string' },
-            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用英文逗号分隔，如 "报销,报销流程")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；0 命中或多命中且无全名精确匹配时返回澄清（候选见 candidates），确认后用「名称(ID)」重发',
+            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用英文逗号分隔，如 "报销,报销流程")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；0 命中或多命中且无全名精确匹配时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
         },
         relatesTo: { type: 'string', description: '可选关联对象 id（仅透传，不影响表单初始化）' },
     }, { required: ['workflow'] }),