weaver-work-cli 0.1.8 → 0.1.20

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

@@ -1,21 +1,25 @@
 /**
- * workflow/form.ts - 发起流程（create）与修改流程表单（edit）的 7 个 operation。
+ * workflow/form.ts - 发起流程（create）与修改流程表单（edit）的 operation 集合。
  *
  * 移植自 Python skill e10_workflow_create.py（4,963 行），行为须与该脚本逐条对齐。
  * 认证由 CLI 托管（host 注入会话），本文件不实现登录/缓存（verify_login_auth /
- * atrust_cookie_diagnosis / get_runtime / state/create_contexts 一律丢弃）。
+ * atrust_cookie_ diagnosis / get_runtime / state/create_contexts 一律丢弃）。
  *
  * 原 Python 用磁盘文件保存「上下文（context）」，本 TS 模块改用 continuation 令牌承载上下文：
- *   createForm   -> 发出 continuation(operation=workflow.createForm) 内嵌表单上下文
- *   createPrepare -> 校验该 continuation，产出预览 + 发出 continuation(operation=workflow.createPrepare)
- *   createApply   -> 校验该 continuation，复核只读字段后 save+create
+ *   createForm    -> 解析可发起工作流（名称→ID，原 createList 的职责）→ 载入表单上下文，
+ *                    发出 continuation(operation=workflow.createForm) 内嵌该上下文
+ *   createRequest -> 校验该 continuation，按 action 一次完成「联动 + 必填校验 + 保存 + 发起」
  *   editLoad / editPrepare / editSave 同理（operation 分别为 workflow.editLoad / workflow.editPrepare）。
+ *
+ * 发起链路**只有两条命令**（2026-09-21 用户裁定，从原 4 条 createList/createForm/createPrepare/
+ * createApply 合并而来）：模型只需「取表单 → 填字段 → createRequest」，不必自己判断必填是否缺失
+ * ——必填判定完全在 CLI 内部按实际所填数据（含联动带出值）实时计算。
  */
 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, } from './shared.js';
-import { workflowValidationError, workflowApiError, workflowPartialError, workflowPolicyError, WorkflowCliError, } from '../errors.js';
-import { FORM_ENDPOINTS, AJAX_QUERY, formApiUrl } from '../endpoints.js';
+import { 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';
 // ---------------------------------------------------------------------------
@@ -82,11 +86,20 @@ function encodeFieldsCompact(fields) {
  * （实测某次会话为此多写 3 个脚本、3 次被 head 截断，白花 6 次工具往返）。
  * 这里补一份**只含可写字段**的紧凑索引（行 = `id|name|subFormId|componentKey|flags`），
  * 体积很小（某 278 字段表单实测 3.7KB，其余字段 17.5KB，合计 21.2KB < 安全线），
- * 足以让模型直接构造 `data` 的键；更细的元数据（browserModule / fileUploadParams / 完整 options）
- * 仍按字段 id 去 resultFile 取。纯结构裁剪，不做任何语义判断。
+ * 足以让模型直接构造 `data` 的键。
+ *
+ * V12.1.37（2026-09-23）：把两类**填值前就要核对、又恰好不在行内**的属性随索引下发 ——
+ * 它们此前只能去 resultFile 取，实测就是那次「二次读取」的主要动因：
+ * - `formatIndex`（字段 id → `format`）：日期/时间字段的格式（`yyyy-MM-dd` 等）。只有 `T` 标记时
+ *   模型知道"有格式要求"却不知道要求什么，只能读 resultFile；实测某会话为它多跑一轮 ≈11 s。
+ * - `uploadLimits`（字段 id → `大小上限|格式限制|数量上限`）：附件字段的上传限制，见 `uploadLimitOf`。
+ *
+ * 仍需按字段 id 去 resultFile 取的只剩 `browserModule` / `browserType` / 完整 `options` 结构等
+ * 低频元数据。纯结构裁剪，不做任何语义判断。
  *
  * @param writableIds   可写字段 id（含系统字段），顺序即输出顺序的同构子集
- * @param sourceFields  字段来源（createForm 传可见字段原对象；editLoad 传 slimFields）
+ * @param sourceFields  字段来源。**必须传已挂上 `fileUploadParams` / `folderDependsOnOption` 的那份**
+ *                      （createForm 传 `slimFields`；传早期的 `visibleFields` 会让 F/D 两个标记恒不出现）
  * @param systemNames   系统字段 id → 中文名（不在 sourceFields 里的兜底）
  */
 function encodeWritableFieldsCompact(writableIds, sourceFields, systemNames) {
@@ -121,6 +134,8 @@ function encodeWritableFieldsCompact(writableIds, sourceFields, systemNames) {
     };
     const rows = [];
     const optionIndex = {};
+    const formatIndex = {};
+    const uploadLimits = {};
     const emitted = new Set();
     const push = (id) => {
         if (emitted.has(id))
@@ -136,6 +151,12 @@ function encodeWritableFieldsCompact(writableIds, sourceFields, systemNames) {
         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) {
@@ -150,12 +171,50 @@ function encodeWritableFieldsCompact(writableIds, sourceFields, systemNames) {
         rows,
         rowCount: rows.length,
         flagLegend: 'R=必填 B=浏览按钮 S=选项 M=多选 E=人员范围 V=发票 D=附件目录随选项 '
-            + 'F=有上传参数(见 resultFile) O=有选项(见 optionIndex) T=有日期/时间格式要求',
+            + '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;
 }
+/**
+ * 附件字段的上传限制 → 一行紧凑描述（`大小上限|格式限制|数量上限`）。
+ *
+ * 只摘模型填值前要核对的三项，**丢掉服务器侧管道**：`customParam`（`authStr`/`authSignatureStr`/
+ * `requestId`/`nodeId`/`identityId`…）、`folderId`/`refId`/`sourceRefId`/`source`/`module` 等，
+ * 单字段原块 ≈700 B 而其中三项限制合计不到 120 B。
+ *
+ * - `sizeLimit` 单位 MB；`formatLimit.mode='white'` 记「白名单」、其余记「黑名单」；
+ *   `formats=['*.*']`（或 `['*']`）记「不限格式」。
+ * - 缺项一律写 `-`，**不要留空**：留空会被读成"限制为 0/不允许"。
+ * - 无 `fileUploadParams` 的字段返回空串（调用方不产出该条目）。
+ */
+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('|');
+}
 /**
  * 大表单输出保护（通用，不针对任何具体工作流/表单）。
  *
@@ -212,58 +271,73 @@ async function compactFormOutput(result, env, resultFileName, fieldsOmittedCompe
     //  ① 安全线改用**美化口径** `stdoutBytesOf()`（与实际 stdout 一致）。此前量压缩 JSON，**低估 1.79 倍**
     //     ⇒ 这一档从未触发，且 `writableFields` 被追加在末尾（起始偏移 31,093），宿主只给 2048 B 预览
     //     ⇒ 模型永远看不到它，只能自写脚本挖 resultFile（实测白烧 4 轮工具往返、约 54 s）。
-    //  ② `conditionalRequired`（278 字段表单实测压缩 10.9 KB / 美化 ≈19.5 KB）与 `editableFields`
-    //     （与 writableFields 冗余）移出 stdout，只留条数 —— 二者合起来才够把体积压进宿主内联区。
+    //  ② `editableFields`（与 writableFields 冗余）移出 stdout，只留可写索引 — 二者合起来才够把体积压进宿主内联区。
     //  ③ `writableFields` 前置到载荷最前，任何截断场景下都先被看到。
-    const condCount = Array.isArray(result.conditionalRequired) ? result.conditionalRequired.length : 0;
     const summary = { ...result };
     delete summary.fields;
-    delete summary.conditionalRequired;
     delete summary.editableFields;
-    const ordered = {};
-    if (fieldsOmittedCompensation)
-        ordered.writableFields = fieldsOmittedCompensation;
-    for (const [key, value] of Object.entries(summary)) {
-        if (value !== undefined)
-            ordered[key] = value;
-    }
-    const fieldsOmittedNotice = `表单字段过多（${fields.length} 个），字段清单已整体移出 stdout，`
+    /**
+     * "字段清单去哪了"的文案——`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。'
-        + (fieldsOmittedCompensation
+        + (withIndex
             ? 'stdout **最前面**已给出全部可写字段的紧凑索引 writableFields：columns 为列名、rows 每行一个字段'
-                + '（`id|name|subFormId|componentKey|flags`，flags 含义见 flagLegend；带选项的字段，'
-                + '其选项名见 optionIndex）。**直接用 writableFields 里的字段 id 构造 data 的键**，'
-                + '不要为了拿字段清单再写脚本解析 resultFile；只有需要某字段更细的元数据'
-                + '（browserModule / fileUploadParams / 完整 options 结构）时，才按该字段 id 从 resultFile 取。'
-            : '构造表单数据前，请按字段 id 从 resultFile 里提取所需键，按需只取几个键、'
-                + '不要把整份 resultFile 读入上下文。')
-        + (condCount
-            ? `为压进体积安全线，条件必填规则（conditionalRequired，${condCount} 条）与可写白名单`
-                + '（editableFields）也已移出 stdout（条数见 conditionalRequiredCount）；'
-                + '需要时按同一个 resultFile 取。'
-            : '')
-        + READ_WHOLE_OUTPUT_HINT;
-    const leadingMeta = {
+                + '（`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,
         persistedResult: true,
         outputBytes: bytes,
         fieldsOmitted: true,
         fieldCount: fields.length,
-        ...(condCount ? { conditionalRequiredCount: condCount } : {}),
-        largeOutputNotice: fieldsOmittedNotice,
+        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(leadingMeta, ordered);
+    // 第一档：可写字段索引 + 摘要（正常的大表单都落在这里）
+    const withIndex = withLeadingMeta(metaOf(true), orderedBody(true));
     if (stdoutBytesOf(withIndex) <= STDOUT_SAFE_BYTES)
         return withIndex;
-    // 索引也放不进安全线（字段数量极端）：退回只留指针，并显式标注已省略。
-    delete ordered.writableFields;
+    // 第二档（字段数量极端）：索引也放不进安全线，退回只留指针，并显式标注索引被省略了。
+    // 2026-09-22 修正：这一档**必须真的把 writableFields 去掉**——此前仍经 `orderedBody(true)` 把它塞回去，
+    // 结果既没压进安全线，又与 `writableFieldsOmitted: true` 自相矛盾、文案还在说"已给出索引"。
     return withLeadingMeta({
-        ...leadingMeta,
+        ...metaOf(false),
         ...(fieldsOmittedCompensation ? { writableFieldsOmitted: true } : {}),
-    }, ordered);
+    }, orderedBody(false));
 }
-async function requestJson(env, method, path, query, body) {
-    const response = await env.host.workflowRequest({ method, path, query, body, operation: path });
+async function requestJson(env, method, path, query, body, options = {}) {
+    const response = await env.host.workflowRequest({
+        method,
+        path,
+        query,
+        body,
+        operation: path,
+        ...(options.tolerateBusinessError ? { tolerateBusinessError: true } : {}),
+    });
     return responseData(response);
 }
 async function getSessionContext(env) {
@@ -1054,11 +1128,12 @@ function applyViewRelateHidden(layoutSubformIds, viewRelateConfig) {
  * 真正未下发时：`requiredFields` 只剩系统字段、`subFormRequired` 恒为 `{}`，**不代表表单没有必填项**。
  *
  * V12.1.27 纠正（此前措辞有硬伤）：原文案把 `missingFields` 也写成"为空不代表没有必填/无法据此校验业务必填"，
- * 与事实相反——本租户的业务必填是**条件必填**，由 `viewLinkages` 的 `required` 规则承载，
- * prepare 阶段按实际所填数据**实时求值**，`missingFields` 完全可信（2026-09-17 真机验证：总部费用报销
+ * 与事实相反——本租户的业务必填多为**条件必填**（`viewLinkages` 的 `required` 规则），
+ * createRequest 阶段按实际所填数据**实时求值**，`missingFields` 完全可信（2026-09-17 真机验证：总部费用报销
  * `报销方式=银行（付公司）` → `missingFields=[账户名称,账号,开户机构名称]`）。原文案会诱导模型对用户说
- * "系统不会校验必填项"，属错误陈述。现改为：静态标记未下发 + 条件必填清单（`conditionalRequired`）+
- * **missingFields 可信、照常 prepare**。
+ * "系统不会校验必填项"，属错误陈述。现改为：静态标记未下发 + **missingFields 可信、照常 prepare**。
+ *
+ * 2026-09-23：`createForm` 不再下发联动规则（原 `conditionalRequired`），必填判断一律以 `missingFields` 为准。
  *
  * 返回 null 表示静态必填信息可用，无需告警。
  */
@@ -1078,43 +1153,415 @@ function requiredInfoWarningText(context) {
     if (business.some((f) => f.required))
         return null;
     return 'OA 未下发该表单的**静态**必填标记，本次 requiredFields / subFormRequired 只含系统字段（流程标题等），'
-        + '但这**不代表该表单没有业务必填项**：业务必填见 conditionalRequired。'
-        + 'missingFields 由 prepare 按实际所填数据实时计算、**可信**——照常 prepare，'
-        + '并把 missingFields 与 conditionalRequired 一次性向用户问齐。'
+        + '但这**不代表该表单没有业务必填项**——业务必填多为「条件必填」，只有按实际所填数据才判定得出。'
+        + 'missingFields 由 createRequest 按实际所填数据实时计算、**可信**：照常发起，'
+        + '返回 NEEDS_INPUT 时把 missingFields 一次性向用户问齐。'
         + '不要对用户说"系统不会校验必填项"。';
 }
 // ---------------------------------------------------------------------------
-// createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
+// 发起侧工作流解析（原 createList 的职责；候选池 = 当前用户「可发起的工作流」）
+// ---------------------------------------------------------------------------
+/**
+ * 把一个「纯名称」切成多个匹配关键词（2026-09-23 用户裁定）。
+ *
+ * 单个格内可用逗号分隔多个关键词（中英文逗号都认），也可用数组多元素表达；命中结果做**并集**，
+ * 目的是**提高候选召回** —— 用户首次要发起某个流程时，多给几个说法更容易命中他真正要发起的那个，
+ * 从而少让用户回来补全名称。
+ *
+ * 去词规则（用户裁定，逐字）：「**去掉一些词：工作流、流程**」。落到实现上是——
+ * **只丢弃"整格就是填充词"的关键词**（`流程` / `工作流` / `工作流程`），其余**原样保留**：
+ * - `"报销,报销流程,流程"` → 关键词 = `报销`、`报销流程`（**两个**，`流程` 被丢掉）；
+ * - `报销流程` **不在词内剥离** —— 它是有效关键词（剥成 `报销` 会让"多关键词"退化成单关键词）。
+ * 匹配不到的关键词在并集里自然贡献为空，无害，所以不必额外清理。
+ */
+function splitCreateKeywords(raw) {
+    const out = [];
+    const seen = new Set();
+    for (const piece of String(raw ?? '').split(/[,，]/u)) {
+        const token = piece.trim();
+        if (!token)
+            continue;
+        // 填充词按**长词优先**脱壳：`工作流程` → 空（`工作流`+`流程` 在 `流` 处重叠，顺序错会漏判）
+        const residue = token.split('工作流程').join('').split('工作流').join('').split('流程').join('');
+        if (!residue.trim())
+            continue;
+        const key = token.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(token);
+    }
+    return out;
+}
+/**
+ * 发起侧名称→ID。
+ *
+ * 与查询侧 `resolveTerm` 的关键差别在**候选池**：这里必须落在「当前用户可发起的工作流」上
+ * （`getNewFlowListData`），而不是流程路径浏览按钮——后者包含用户看得见、但没有发起权限的流程。
+ *
+ * 判据（与查询侧同一套，避免出现"查询能选中、发起选不中"的错位）：
+ * - **0 命中 → 澄清**：不能把「没听懂你的条件」伪装成「没有这条流程」，否则模型会如实转述成
+ *   "没有该工作流"，用户拿不到可操作的信息；
+ * - 1 命中 → 直接用；
+ * - 多命中但候选中**恰有一个与所写名称完全一致** → 直接用，不为"要不要多打几个字"再问一次；
+ * - 多命中且没有完全一致的 → 澄清并列出候选（`display` 即 `名称(ID)`，用户选定后原样回传）。
+ *
+ * 名称格支持**多关键词**（`"报销,报销流程"`，见 `splitCreateKeywords`）：各关键词命中做并集去重后，
+ * 再走上面同一套判据。**只发一次** `getNewFlowListData` 而不是每个关键词并行各发一次 —— 该接口
+ * 请求体固定为 `{wfpBelongTypeCode, loadOfsFlow, clientCtrl}`、**没有任何关键词入参**（V11.3 Python
+ * 基线 `e10_workflow_create.py:395-436` 同样是取全量后本地过滤；真机单笔 ≈1,649 ms / 228,929 B），
+ * 并行 N 次只会拿到 N 份相同的全量列表，结果与"单次请求 + 本地多关键词过滤"完全等价却要付 N 倍开销。
+ */
+async function resolveCreateWorkflow(rawWorkflow, env) {
+    const rawTerms = [];
+    for (const item of toArray(rawWorkflow)) {
+        const text = String(item ?? '').trim();
+        if (text)
+            rawTerms.push(text);
+    }
+    // 澄清文案里回显的是**用户原话**（不是切分后的关键词）——用户要能认出自己给的条件
+    const queryText = rawTerms.join('、');
+    if (!rawTerms.length) {
+        throw workflowClarificationError('workflow', '', '要发起哪个流程？请提供可发起工作流的名称、`名称(ID)` 或工作流 ID 后再继续。');
+    }
+    // 先做**纯本地**的解析：显式 ID（`名称(ID)` / 纯数字）与名称关键词（一格可含多个，见
+    // `splitCreateKeywords`）。这一步不依赖远端结果，于是能先判"到底有没有可用条件"——
+    // 一个关键词都没解析出来（如只传了 `流程`）时**连可发起列表都不去拉**
+    // （该接口真机单笔 ≈1,649 ms / 228,929 B），与"完全不传 workflow"同一口径。
+    const explicitIds = new Set();
+    const nameTerms = [];
+    const keywordSeen = new Set();
+    for (const term of rawTerms) {
+        const parsed = parseNameWithId(term);
+        // 纯数字同样按 ID 处理（`parseNameWithId` 只认 "名称(数字)" 形态）
+        const explicitId = parsed.id ?? (/^[0-9]+$/.test(term) ? term : '');
+        if (explicitId) {
+            explicitIds.add(explicitId);
+            continue;
+        }
+        for (const keyword of splitCreateKeywords(parsed.name)) {
+            const key = keyword.toLowerCase();
+            if (keywordSeen.has(key))
+                continue;
+            keywordSeen.add(key);
+            nameTerms.push(keyword);
+        }
+    }
+    if (!explicitIds.size && !nameTerms.length) {
+        throw workflowClarificationError('workflow', queryText, '要发起哪个流程？请提供可发起工作流的名称、`名称(ID)` 或工作流 ID 后再继续。');
+    }
+    const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, {
+        wfpBelongTypeCode: '1', loadOfsFlow: '0', clientCtrl: 1,
+    });
+    // requestJson 内部已解包一层（responseData），此处不可再取 .data
+    const data = (response && typeof response === 'object') ? response : null;
+    if (!data || typeof data !== 'object')
+        throw workflowApiError('format_error', '工作流列表返回 data 格式错误');
+    const all = simplifyWorkflows(data);
+    const picked = [];
+    const seen = new Set();
+    for (const explicitId of explicitIds) {
+        const hit = all.find((item) => String(item.id ?? '') === explicitId);
+        if (hit && !seen.has(String(hit.id))) {
+            seen.add(String(hit.id));
+            picked.push(hit);
+        }
+    }
+    // 名称关键词：逐个取命中，**并集去重**（多给几个说法只扩大候选面，不改变下面的命中判据）
+    for (const keyword of nameTerms) {
+        for (const item of simplifyWorkflows(data, keyword)) {
+            if (seen.has(String(item.id)))
+                continue;
+            seen.add(String(item.id));
+            picked.push(item);
+        }
+    }
+    picked.sort((a, b) => (a.typename + a.workflowname + a.id).localeCompare(b.typename + b.workflowname + b.id));
+    if (picked.length === 1) {
+        const only = picked[0];
+        const id = String(only.id);
+        return { id, name: String(only.workflowname ?? ''), source: explicitIds.has(id) ? 'workflowId' : 'single' };
+    }
+    if (picked.length > 1) {
+        const wanted = new Set(nameTerms.map((t) => t.trim().toLowerCase()).filter(Boolean));
+        const exact = picked.filter((item) => wanted.has(String(item.workflowname ?? '').trim().toLowerCase()));
+        // 多命中时有唯一全名精确匹配 → 直接选中（与查询侧 exact_candidates 优选同一判据）
+        if (exact.length === 1) {
+            return { id: String(exact[0].id), name: String(exact[0].workflowname ?? ''), source: 'exactName' };
+        }
+        const list = exact.length ? exact : picked;
+        throw workflowClarificationError('workflow', queryText, `「${queryText}」匹配到 ${list.length} 个可发起的工作流，且其中没有与所写名称完全一致的，`
+            + '请确认要发起的具体工作流。', list.slice(0, 10).map((item, index) => ({
+            index: index + 1,
+            id: String(item.id),
+            name: String(item.workflowname ?? ''),
+            display: `${String(item.workflowname ?? '')}(${String(item.id)})`,
+        })));
+    }
+    throw workflowClarificationError('workflow', queryText, `「${queryText}」在当前账号下没有匹配到可发起的工作流（也可能已停用或无发起权限）。`
+        + '请核对名称，或给出准确的完整名称 / 工作流 ID 后再继续。');
+}
+/**
+ * 从「全局 + 该工作流维度」的合并记忆里**只取工作流维度那一段**。
+ *
+ * 背景（2026-09-23 实测 + 用户裁定）：`POST …memoryPrompt` 带 `workflowId` 时返回的是**全集** ——
+ * `--- user.md ---` / `--- memory.md ---`（全局画像 + 全局别名映射）+ `--- memory_<workflowId>.md ---`
+ * （该工作流维度）。于是 `launchPreferences` 与入口处读过的无参 `workflow.memoryPrompt`（纯全局）
+ * **内容重叠**：真机实测同一租户 `promptText` 2,467 字符 = 全局 543 + 工作流维度 1,924，
+ * 同一段全局记忆会在上下文里出现两次。而 `launchPreferences` 的语义是「**该工作流的**发起偏好」，
+ * 全局那份已由入口读取覆盖，不应重复下发。
+ *
+ * 故只保留标记 `--- memory_<workflowId>.md ---` 及其**之后**的内容：
+ * - 找得到该标记 ⇒ 从标记处截断（标记行本身保留 —— 它自带 workflowId 作用域，便于模型判断归属）；
+ * - 找不到 ⇒ **整体丢弃**（说明这次返回里没有该工作流维度的内容，只剩与入口重复的全局部分）。
+ *
+ * ⚠️ 这是**服务端支持前的兼容裁剪**：等服务端改为「传 workflowId 只回工作流维度记忆」后，
+ * 若返回里仍带 `--- memory_<workflowId>.md ---` 分隔头，本函数行为不变、删掉也等价；
+ * 若不再带该分隔头，**这段会把正常内容整体丢掉** —— 届时必须一并移除本函数与它的调用。
+ */
+function extractWorkflowMemorySection(promptText, workflowId) {
+    const text = String(promptText ?? '');
+    const id = String(workflowId ?? '').trim();
+    if (!text.trim() || !id)
+        return '';
+    const marker = `--- memory_${id}.md ---`;
+    const at = text.indexOf(marker);
+    if (at < 0)
+        return '';
+    return text.slice(at).trim();
+}
+/**
+ * 顺带取回用户在这条工作流上的发起偏好（`buildAgentMemoryPrompt`，带 `workflowId`）。
+ *
+ * `promptText` **只含该工作流维度的记忆**（全局画像/全局别名由入口的无参 `workflow.memoryPrompt`
+ * 覆盖，这里经 `extractWorkflowMemorySection` 裁掉，避免同一段全局记忆在上下文里出现两次）。
+ *
+ * best-effort：读记忆失败（未开通记忆 / 接口不可用）不是错误——一律按新用户处理，
+ * 只体现在 `launchPreferences.available` 上，绝不阻断表单载入（与 `workflow.memoryPrompt` 同口径）。
+ */
+async function fetchLaunchPreferences(workflowId, env) {
+    const result = { available: false, workflowId, promptText: '' };
+    try {
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.MEMORY_PROMPT,
+            operation: 'workflow.createForm',
+            body: { appid: resolveMemoryAppId(), dynamicContextParams: { workflowId } },
+        });
+        // 该接口原始返回是 {code,msg,status,data:"<markdown>",fail}，业务成功标志是 status/fail
+        // **不是 success**——这里**不能**用 responseData 解包（会把 data 里的 markdown 当主体，
+        // 导致 promptText 恒空）。与 workflow.memoryPrompt 同源。
+        // 只认 `data`（字符串）作为偏好正文：**不回退 `msg`**——`msg` 里是「接口返回成功」这类
+        // 通用提示，回退它会让"没配记忆"的环境被读成有一条内容是"接口返回成功"的偏好。
+        const body = (response && typeof response === 'object' ? response : {});
+        const rawPromptText = typeof body.data === 'string' ? body.data.trim() : '';
+        const promptText = extractWorkflowMemorySection(rawPromptText, workflowId);
+        const businessOk = body.fail !== true && body.status !== false && body.success !== false;
+        result.available = Boolean(businessOk && promptText);
+        result.promptText = promptText;
+    }
+    catch (error) {
+        // 404 ＝ 该智能体/工作流还没有记忆条目（未开通记忆），属**正常的新用户状态**，不是失败：
+        // 保持 `available:false` + `promptText:''`，**不加任何"失败"提示**、也不阻断任务。
+        // 其它错误才提示"读取失败、按新用户处理"。
+        if (!isNotFoundError(error)) {
+            result.note = '该工作流的记忆偏好读取失败，按新用户处理，不要重试。';
+        }
+    }
+    return result;
+}
+/**
+ * 是否是「资源不存在」类错误（HTTP 404）。
+ *
+ * 真机上该错误由 host 统一抛成 `workflowApiError('http_error', 'OA 接口 HTTP 404', {code:404, details:{status:404}})`，
+ * 故同时认 `code` 与 `details.status` 两处。不依赖类实例判断，避免把跨包包装过的错误漏掉。
+ */
+function isNotFoundError(error) {
+    const record = (error && typeof error === 'object') ? error : {};
+    if (Number(record.code) === 404)
+        return true;
+    const details = record.details;
+    return Boolean(details && typeof details === 'object' && Number(details.status) === 404);
+}
 // ---------------------------------------------------------------------------
+// createForm：解析工作流 + loadBase/loadFrame/loadMinor/formLayout + 字段输出
+// ---------------------------------------------------------------------------
+/**
+ * `workflow.createForm` —— **一条命令**完成「解析可发起工作流 → 载入发起表单 → 取回该工作流发起偏好」。
+ *
+ * 入参只需要工作流参数（`名称(ID)` / `名称` / `id`，与 `workflow.search` 的 `workflow` 同形态）。
+ * 解析不出唯一目标时走澄清（`ok:true` + `status:NEEDS_CLARIFICATION`，与查询侧同一套约定），
+ * 此时候选之外**不返回任何表单数据**。
+ */
+/**
+ * 从 `loadBaseParam` 的返回里读出**「为什么进不去这张表单」**的结论。
+ *
+ * 真机实测（2026-09-22，三种形态都取过原文）：
+ * - 正常可发起：`data.commonParam.authInfo = {canView:true, verifyRight:"VIEW_RIGHT", ...}`，且有 `requestInfo.workflowName`；
+ * - **ID 不存在**：`canView:false`、`verifyRight:"WORKFLOW_NOT_EXIST"`、`exceptionType.desc:"当前工作流不存在，请联系管理员"`；
+ * - **存在但无发起权限**：`canView:false`、`verifyRight:"NO_CREATE_RIGHT"`、`exceptionType.desc:"无流程创建权限"`、`mainPrompt:"无发起权限"`。
+ *
+ * 这三种情况下 `data` 里**只有** `cmdExeLogs`/`PLExecuteInfo`/`commonParam`——没有 `requestInfo`、
+ * 更没有表单框架，所以必须在 `parseRuntime` 之前先判，否则只会得到一个语焉不详的格式错误。
+ *
+ * 判据保守：只认 `authInfo` 存在且 `canView === false`；老响应没有 `authInfo` 时不设闸（照常往下走）。
+ */
+function readCreateFormBlock(base) {
+    const data = (base && typeof base === 'object') ? base : null;
+    const common = (data?.commonParam && typeof data.commonParam === 'object') ? data.commonParam : null;
+    const auth = (common?.authInfo && typeof common.authInfo === 'object') ? common.authInfo : null;
+    if (!auth)
+        return null;
+    if (auth.canView !== false)
+        return null;
+    const exc = (auth.exceptionType && typeof auth.exceptionType === 'object') ? auth.exceptionType : {};
+    const detail = String(exc.exceptionDesc ?? exc.desc ?? auth.noRightTip ?? '').trim();
+    const right = String(auth.verifyRight ?? '').trim().toUpperCase();
+    if (right === 'WORKFLOW_NOT_EXIST')
+        return { reason: 'workflow_not_exist', detail };
+    return { reason: 'no_create_right', detail };
+}
+/**
+ * 把「进不去这张表单」翻成**可判别**的澄清。
+ *
+ * 两句话必须分开写：「ID 不存在」与「存在但没有发起权限」是完全不同的事实，
+ * 混成一句就会让模型把后者说成前者（把"没权限"伪装成"没有这条流程"）。
+ * `clarificationReason` 随信封下发，模型据此选话术（文案见 `operations.ts` 的 `clarificationNote`）。
+ */
+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, `工作流 ID「${workflowId}」**存在**，但当前账号没有发起权限`
+        + `${block.detail ? `（${block.detail}）` : ''}。`
+        + '请改用其他可发起的流程，或联系管理员为该流程授予发起权限。', [], { clarificationReason: 'no_create_right' });
+}
+/**
+ * 入参是否已是「单条、且自带显式 ID」的工作流参数（`名称(ID)` 或纯 ID）。
+ *
+ * 该形态下**完全不需要**可发起工作流列表：权威名称由 `loadBaseParam` 的
+ * `requestInfo.workflowName` 给出，可发起性由同一接口的 `commonParam.authInfo` 给出
+ * （见 `readCreateFormBlock`）。因此这条路径会**跳过** `getNewFlowListData`
+ * ——真机实测该接口单笔 **1.65 s / 228,929 B**，是本命令最贵的一笔。
+ *
+ * 不满足该形态时返回 null，调用方退回「靠列表解析出 id」的原口径。
+ */
+function singleExplicitWorkflowId(rawWorkflow) {
+    const terms = toArray(rawWorkflow).map((item) => String(item ?? '').trim()).filter(Boolean);
+    if (terms.length !== 1)
+        return null;
+    const parsed = parseNameWithId(terms[0]);
+    return parsed.id ?? (/^[0-9]+$/.test(terms[0]) ? terms[0] : '');
+}
+/** 表单载入 + 该工作流的发起偏好：两者只共享 `workflowId`，可以并行。 */
+async function loadCreateFormPack(workflowId, env) {
+    const [{ data, writableFieldsCompact }, launchPreferences] = await Promise.all([
+        buildCreateFormData(workflowId, env),
+        // 记忆读取是 best-effort（内部全 catch），不会把表单载入的错误顶掉。
+        fetchLaunchPreferences(workflowId, env),
+    ]);
+    return { data, writableFieldsCompact, launchPreferences };
+}
 async function commandCreateForm(args, env) {
-    const workflowId = String(args.workflowId ?? '').trim();
-    if (!workflowId)
-        throw workflowValidationError('workflow_id_required', 'workflowId 必填');
+    // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
+    // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
+    await env.host.getSession();
+    let target;
+    let pack;
+    const explicitId = singleExplicitWorkflowId(args.workflow);
+    if (explicitId) {
+        // 自带显式 ID ⇒ **一个列表请求都不发**（真机该接口 1.65 s / 228,929 B，是本命令最贵的一笔）。
+        // 权威名称由 loadBaseParam 的 `requestInfo.workflowName` 给出、可发起性由同接口的
+        // `commonParam.authInfo` 给出；该 ID 不可用时由载入表单一侧的 `readCreateFormBlock`
+        // 抛出**可判别**的澄清（不是把它伪装成"没有匹配到可发起的工作流"）。
+        target = { id: explicitId, name: '', source: 'workflowId' };
+        pack = await loadCreateFormPack(explicitId, env);
+    }
+    else {
+        target = await resolveCreateWorkflow(args.workflow, env);
+        pack = await loadCreateFormPack(target.id, env);
+    }
+    return workflowSuccess('workflow.createForm', await compactFormOutput({
+        ...pack.data,
+        workflow: { ...(pack.data.workflow || {}), selectionSource: target.source },
+        launchPreferences: pack.launchPreferences,
+    }, env, 'last_create_form.json', pack.writableFieldsCompact));
+}
+// ---------------------------------------------------------------------------
+// createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
+// ---------------------------------------------------------------------------
+/**
+ * 载入发起表单（原 `createForm` 的全部取数逻辑，逐行保留）——产出表单上下文与输出契约。
+ *
+ * 与旧版的差别只有一处：`workflowId` 由调用方（`resolveCreateWorkflow`）解析好后传进来，
+ * 不再是本函数的入参校验点。
+ */
+async function buildCreateFormData(workflowId, env) {
     const query = { workflowId, isCreate: 1, ...AJAX_QUERY };
     const body = { workflowId, isCreate: 1, isMobile: 0 };
-    const baseResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadBase, query, body);
-    const frameResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadFrame, query, body);
+    // 2026-09-22：这四个接口**彼此没有数据依赖**（入参只需要 workflowId，见各自的 query/body），
+    // 真机实测各 171–429 ms、串行合计约 1.1 s；并行后只受最慢的一个约束。
+    // `loadMinorInfo` / `tenant/setting` 仍是 best-effort（失败只降级、不阻断），所以各自 catch 成
+    // 结果对象再判定 —— 不能让它们的失败经由 Promise.all 把整个命令带崩（后者语义与串行版一致）。
+    // `loadBaseParam` / `loadFrameParam` 也改成"先收着、后判定"：目的是让 base 的权限结论
+    // **优先于** frame 的泛化错误浮出（理由见下面的判定顺序）。
+    const [baseOutcome, frameOutcome, minorOutcome, tenantOutcome] = await Promise.all([
+        // `tolerateBusinessError`：该接口用 `status:false` + `commonParam.authInfo` 表达
+        // 「不存在 / 无发起权限」，走带业务过滤的通道只会拿到"接口返回状态异常，code=200"。
+        requestJson(env, 'POST', FORM_ENDPOINTS.loadBase, query, body, { tolerateBusinessError: true })
+            .then((value) => ({ ok: true, value }))
+            .catch((error) => ({ ok: false, error })),
+        requestJson(env, 'POST', FORM_ENDPOINTS.loadFrame, query, body)
+            .then((value) => ({ ok: true, value }))
+            .catch((error) => ({ ok: false, error })),
+        requestJson(env, 'POST', FORM_ENDPOINTS.loadMinor, query, { workflowId, isCreate: 1, isMobile: 0 })
+            .then((value) => ({ ok: true, value }))
+            .catch(() => ({ ok: false, value: null })),
+        requestJson(env, 'POST', FORM_ENDPOINTS.tenantSetting, undefined, { setType: [] })
+            .then((value) => ({ ok: true, value }))
+            .catch(() => ({ ok: false, value: null })),
+    ]);
+    // 「为什么进不去这张表单」必须**先于**其它接口的错误判定：
+    // ID 不存在 / 无发起权限时，真机上 `loadFrameParam`、`loadMinorInfo` 会返回
+    // `code:500「无流程查看权限」`——那是**后果**不是**原因**。若让它先外溢，模型只能对着
+    // "无流程查看权限"猜，说不出到底是「ID 不存在」还是「存在但没权限」。
+    if (baseOutcome.ok) {
+        const blocked = readCreateFormBlock(baseOutcome.value);
+        if (blocked)
+            throw createFormBlockedError(workflowId, blocked);
+    }
+    if (!baseOutcome.ok)
+        throw baseOutcome.error;
+    if (!frameOutcome.ok)
+        throw frameOutcome.error;
+    const minorWarningText = 'loadMinorInfo 获取系统字段权限失败，跳过系统字段（流程标题/紧急程度/密级）必填校验';
     let minorInfo = {};
     let minorWarning = null;
-    try {
-        const minorResp = await requestJson(env, 'POST', FORM_ENDPOINTS.loadMinor, query, { workflowId, isCreate: 1, isMobile: 0 });
-        minorInfo = parseMinorInfo(minorResp);
+    if (minorOutcome.ok) {
+        try {
+            minorInfo = parseMinorInfo(minorOutcome.value);
+        }
+        catch {
+            minorInfo = {};
+            minorWarning = minorWarningText;
+        }
     }
-    catch {
-        minorInfo = {};
-        minorWarning = 'loadMinorInfo 获取系统字段权限失败，跳过系统字段（流程标题/紧急程度/密级）必填校验';
+    else {
+        minorWarning = minorWarningText;
     }
-    const base = baseResp;
-    const frameData = frameResp;
+    const base = baseOutcome.value;
+    const frameData = frameOutcome.value;
     const runtime = parseRuntime(base, workflowId);
     const frame = parseFrame(frameData, runtime.node_id);
+    // tenantSetting 取不到时按 {} 处理（与串行版的 catch 分支同口径）。
     let tenantSetting = {};
-    try {
-        const settingResp = await requestJson(env, 'POST', FORM_ENDPOINTS.tenantSetting, undefined, { setType: [] });
-        tenantSetting = parseTenantSetting(settingResp);
-    }
-    catch {
-        tenantSetting = {};
+    if (tenantOutcome.ok) {
+        try {
+            tenantSetting = parseTenantSetting(tenantOutcome.value);
+        }
+        catch {
+            tenantSetting = {};
+        }
     }
     const layoutResp = await requestJson(env, 'POST', formApiUrl(FORM_ENDPOINTS.formLayout, frame.relate_type), { formId: frame.form_id, ...AJAX_QUERY }, buildLayoutRequest(workflowId, runtime, frame));
     const layoutData = layoutResp;
@@ -1178,7 +1625,7 @@ async function commandCreateForm(args, env) {
                 defaults.push(d);
         }
     }
-    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = computeLinkageVisibility(layoutData.viewLinkages, [], defaults, onLoadLinkage, systemFieldValues);
+    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = computeLinkageVisibility(layoutData.viewLinkages, [], defaults, onLoadLinkage, systemFieldValues, fields);
     const mainHidden = new Set(rowHidden.main || []);
     const initialHidden = new Set(fields.filter((f) => f.display === false).map((f) => String(f.id ?? '')));
     if (initialHidden.size) {
@@ -1356,8 +1803,6 @@ async function commandCreateForm(args, env) {
         onLoadLinkage,
     };
     const token = await env.continuation.issue({ operation: 'workflow.createForm', baseUrl: session.baseUrl, profile: session.profile, userId: session.userId, payload: context }, CONTINUATION_TTL_MS);
-    // 条件必填清单（V12.1.27）：viewLinkages 里的 required 规则原样结构化，form 阶段即可主动问齐必填项。
-    const conditionalRequired = conditionalRequiredFields(layoutData.viewLinkages, rawFieldsById);
     const requiredFieldIds = requiredFieldsWithSystem(requiredFieldsList, runtime, minorInfo.permissions || {});
     // 可写字段 = 必填（主表 + 明细，含系统字段）+ 其余可编辑字段。
     // 只在 `fields` 真被整体移出 stdout 时才会随输出（由 compactFormOutput 决定）。
@@ -1370,31 +1815,38 @@ async function commandCreateForm(args, env) {
     }
     for (const f of editableFieldsList)
         writableFieldIds.push(String(f?.id ?? ''));
-    const writableFieldsCompact = encodeWritableFieldsCompact([...new Set(writableFieldIds)], visibleFields, SYSTEM_FIELD_KEYS);
-    return workflowSuccess('workflow.createForm', await compactFormOutput({
-        status: 'FORM_READY',
-        contextId: token,
-        requestId: runtime.request_id,
-        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: editableFieldsList.map((f) => String(f.id ?? '')),
-        fields: slimFields,
-        initialValues: initValues,
-        systemFields: {
-            permissions: minorInfo.permissions || {},
-            defaults: context.systemFields.defaults,
-            levelOptions: minorInfo.level_options || [],
-            secLevelOptions: minorInfo.sec_level_options || [],
+    // 字段来源必须是 slimFields（它才带 fileUploadParams / folderDependsOnOption）：传 visibleFields
+    // 会让 F/D 两个标记恒不出现，uploadLimits 也整块缺失。
+    const writableFieldsCompact = encodeWritableFieldsCompact([...new Set(writableFieldIds)], slimFields, SYSTEM_FIELD_KEYS);
+    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: editableFieldsList.map((f) => String(f.id ?? '')),
+            fields: slimFields,
+            initialValues: initValues,
+            systemFields: {
+                permissions: minorInfo.permissions || {},
+                defaults: context.systemFields.defaults,
+                levelOptions: minorInfo.level_options || [],
+                secLevelOptions: minorInfo.sec_level_options || [],
+            },
+            systemFieldWarning: minorWarning,
+            requiredInfoWarning: requiredInfoWarningText(context),
+            // 原 Python 把完整 context 落盘；此处通过 continuation 承载，返回结构保持文档契约。
+            continuation: token,
         },
-        systemFieldWarning: minorWarning,
-        requiredInfoWarning: requiredInfoWarningText(context),
-        ...(conditionalRequired.length ? { conditionalRequired } : {}),
-        // 原 Python 把完整 context 落盘；此处通过 continuation 承载，返回结构保持文档契约。
-        continuation: token,
-    }, env, 'last_create_form.json', writableFieldsCompact));
+        writableFieldsCompact,
+    };
 }
 // ---------------------------------------------------------------------------
 // 输入拆分 / 字段绑定 / 只读校验
@@ -2213,145 +2665,15 @@ function _linkageOptions(sourceContent) {
                 result.push([tv, name]);
         }
     }
-    return result;
-}
-/**
- * 联动条件里的"期望取值"（`sourceContent` 是 JSON 字符串）。
- *
- * 与 `_linkageOptions`（只服务条件命中判定，取 id/name 两元组）分开：本函数保留 **id + content**，
- * 并在没有任何选项列表时回退到 `dataOptions`/`content` 标量（如 `{"formField":{"id":"…"},"content":"1"}`），
- * 供 `conditionalRequired` 原样展示条件取值用。
- */
-function _linkageConditionValues(sourceContent) {
-    if (!sourceContent || typeof sourceContent !== 'string' || !sourceContent.trim())
-        return [];
-    let data;
-    try {
-        data = JSON.parse(sourceContent);
-    }
-    catch {
-        return [];
-    }
-    if (!data || typeof data !== 'object')
-        return [];
-    const result = [];
-    for (const item of data.dataOptions || []) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const id = String(item.optionId ?? '').trim();
-        const content = String(item.content ?? '').trim();
-        if (id)
-            result.push(content ? { id, content } : { id });
-        else if (content)
-            result.push({ content });
-    }
-    for (const item of data.optionValues || []) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const id = String(item.textValue ?? '').trim();
-        const content = String(item.name ?? '').trim();
-        if (id)
-            result.push(content ? { id, content } : { id });
-        else if (content)
-            result.push({ content });
-    }
+    // 标量取值回退（2026-09-22）：形如 `{"formField":{"id":"…"},"content":"1"}` 的条件（本租户
+    // 「总部费用报销」的 `发票扫描` 就是这一形态）既没有 dataOptions 也没有 optionValues，旧实现返回 []
+    // ⇒ 调用处 `!condValues.length` 直接 `continue` ⇒ **整条条件被静默丢弃**（既不算成立也不算不成立）。
+    // 后果：`发票扫描 ≠ 1` 从规则里消失 ⇒ 用户**已经扫描过发票**（`发票扫描="1"`）时该规则照样命中，误报必填。
+    // 标量取值的统一口径就是回退 `content`。
     if (!result.length && data.content !== undefined && data.content !== null) {
-        const content = String(data.content).trim();
-        if (content)
-            result.push({ content });
-    }
-    return result;
-}
-/**
- * 「条件必填」清单（V12.1.27 新增能力）。
- *
- * 背景：本租户 OA 的 `getFormLayout` 不下发静态必填标记（`viewRelateConfig` 为空、布局组件 `required`
- * 全为 false），业务必填**只以「显示属性联动」形式存在**——`viewLinkages[]` 中 `linkageProp='required'`
- * 的规则：条件命中时该字段才变必填。
- *
- * 这些规则原先只在 prepare 阶段按"实际所填数据"参与必填计算（命中才出现在 `missingFields`），
- * form 阶段模型完全看不到 ⇒ 模型无法在发起前主动向用户问齐必填项，只能等用户恰巧填对触发字段
- * （2026-09-17 分享会话实证：模型只能说"拿不到必填信息"，用户此前也反复反馈"没有必填字段"）。
- *
- * 本函数把规则**按 OA 原样结构化输出**（不评价、不做语义改写、不做条件求值）：`match` 取
- * `condition.detailType`（AND/OR，缺省 AND），`term` 取 `detailSymbol` 原值
- * （EQUAL/UN_EQUAL/IN/NOT_IN/NULL/NOT_NULL），`values` 为该条件的期望取值。
- * **条件是否命中仍以 prepare 的 `missing_fields` 为准**。
- * 无 required 规则时返回空数组（调用方按需省略该键）。
- */
-function conditionalRequiredFields(linkages, rawFieldsById) {
-    if (!Array.isArray(linkages) || !linkages.length)
-        return [];
-    const fieldMeta = (fieldId) => {
-        const raw = rawFieldsById[fieldId];
-        if (!raw || typeof raw !== 'object')
-            return { name: '', subFormId: '' };
-        return {
-            name: String(raw.title ?? raw.name ?? raw.dataKey ?? '').trim(),
-            subFormId: String(raw.subFormId ?? '').trim(),
-        };
-    };
-    const result = [];
-    const seen = new Set();
-    for (const linkage of linkages) {
-        if (!linkage || typeof linkage !== 'object')
-            continue;
-        const condition = (linkage.condition && typeof linkage.condition === 'object') ? linkage.condition : null;
-        if (!condition)
-            continue;
-        const conditionDetails = Array.isArray(condition.conditionDetails) ? condition.conditionDetails : [];
-        const when = [];
-        for (const cd of conditionDetails) {
-            if (!cd || typeof cd !== 'object')
-                continue;
-            const conditionFieldId = String(cd.targetId ?? '').trim();
-            if (!conditionFieldId)
-                continue;
-            const item = { fieldId: conditionFieldId };
-            const meta = fieldMeta(conditionFieldId);
-            if (meta.name)
-                item.fieldName = meta.name;
-            item.term = String(cd.detailSymbol ?? 'EQUAL').trim().toUpperCase();
-            const sourceType = String(cd.sourceType ?? 'CONSTANT').trim().toUpperCase();
-            if (sourceType !== 'CONSTANT') {
-                item.sourceType = sourceType;
-                const sourceFieldId = String(cd.sourceId ?? '').trim();
-                if (sourceFieldId)
-                    item.sourceFieldId = sourceFieldId;
-            }
-            const values = _linkageConditionValues(cd.sourceContent);
-            if (values.length)
-                item.values = values;
-            when.push(item);
-        }
-        if (!when.length)
-            continue;
-        const match = String(condition.detailType ?? 'AND').trim().toUpperCase() || 'AND';
-        const details = Array.isArray(linkage.linkageDetails) ? linkage.linkageDetails : [];
-        for (const ld of details) {
-            if (!ld || typeof ld !== 'object')
-                continue;
-            if (String(ld.linkageProp ?? '').trim().toLowerCase() !== 'required')
-                continue;
-            for (const target of String(ld.linkageValue ?? '').split(',')) {
-                const fieldId = target.trim();
-                if (!fieldId)
-                    continue;
-                const dedupeKey = [fieldId, match, JSON.stringify(when)].join('\u0000');
-                if (seen.has(dedupeKey))
-                    continue;
-                seen.add(dedupeKey);
-                const meta = fieldMeta(fieldId);
-                const item = { fieldId };
-                if (meta.name)
-                    item.fieldName = meta.name;
-                if (meta.subFormId)
-                    item.subFormId = meta.subFormId;
-                item.match = match;
-                item.when = when;
-                result.push(item);
-            }
-        }
+        const scalar = String(data.content).trim();
+        if (scalar)
+            result.push([scalar, scalar]);
     }
     return result;
 }
@@ -2571,7 +2893,7 @@ function mergeLinkageDetails(merged, linkageDetails) {
     }
     return result;
 }
-function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, systemFieldValues) {
+function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, systemFieldValues, fields) {
     const hiddenSubforms = new Set();
     const rowHidden = {};
     const rowExtraRequired = {};
@@ -2632,6 +2954,47 @@ function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, s
     }
     if (!fieldValues.main)
         fieldValues.main = {};
+    const allRowKeys = Object.keys(fieldValues);
+    /**
+     * 主表作用域字段判定 —— 用于把「主表条件」与「明细行条件」分开求值。
+     *
+     * 背景（2026-09-20 真机 + 配置双证）：本租户「总部费用报销」有一条 required 规则是
+     * `相关流程`(明细) ⇐ `发票扫描`(主表) UN_EQUAL "1" AND `费用类型（科目）`(明细) EQUAL 5301手机话费
+     * AND `申请人(废弃)`(主表) NOT_IN […9 人]。旧实现把每个条件都按 `rowKey` 求命中行再求交，
+     * 而主表条件只能落在 `'main'` 桶、明细条件落在 `'<subFormId>:<idx>'` 桶 ⇒ **AND 交集恒空
+     * ⇒ 规则永不命中**，明细行的条件必填被**静默漏报**（`missingFields` 里从不出现 `相关流程`，
+     * `linkageResult` 恒空），模型据此认为"没有新增必填"。
+     *
+     * 口径：主表条件与"具体哪一明细行"无关 ⇒ 它成立时**对所有行放行**（不限制），不成立时给空集
+     * （AND 判死）。只含主表条件的规则因此行为不变（`'main'` 仍在放行集合里），只含明细条件的规则
+     * 完全不变。
+     *
+     * **补记（2026-09-22 真机复核）**：上面这个作用域修复只解决了"交集恒空"的一半。这条规则在修好作用域后
+     * **仍然**判死，原因在另一处：它的第一条必要条件 `发票扫描 UN_EQUAL "1"` 的前提字段在本租户从来拿不到值，
+     * 而求值时要求 `values.length`。现已按「空值即 null ⇒ 与常量不相等」统一口径修正（见下方
+     * `UN_EQUAL`/`NOT_IN` 分支），并补上标量 `content` 条件的解析回退（见 `_linkageOptions`），
+     * 否则该条件会被整条丢弃、导致"已扫描发票"时反而误报必填。
+     */
+    const mainScopeFieldIds = new Set();
+    for (const f of Array.isArray(fields) ? fields : []) {
+        if (!f || typeof f !== 'object')
+            continue;
+        const id = String(f.id ?? '').trim();
+        if (!id)
+            continue;
+        if (!String(f.subFormId ?? '').trim())
+            mainScopeFieldIds.add(id);
+    }
+    /** 无字段元数据时的兜底：只要该字段在任一明细行桶里出现过，就按明细作用域处理 */
+    const isMainScopeField = (fieldId) => {
+        if (mainScopeFieldIds.has(fieldId))
+            return true;
+        if (mainScopeFieldIds.size)
+            return false;
+        if (/^(REQUEST_|SECLEVEL|system_)/u.test(fieldId))
+            return true;
+        return !allRowKeys.some((key) => key !== 'main' && Object.prototype.hasOwnProperty.call(fieldValues[key], fieldId));
+    };
     for (const linkage of linkages) {
         if (!linkage || typeof linkage !== 'object')
             continue;
@@ -2664,8 +3027,9 @@ function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, s
             }
             if (detailSymbol !== 'NULL' && detailSymbol !== 'NOT_NULL' && !sourceIsVariable && !condValues.length)
                 continue;
+            const mainScope = isMainScopeField(triggerId);
             const matchedRows = new Set();
-            for (const rowKey of Object.keys(fieldValues)) {
+            for (const rowKey of mainScope ? ['main'] : allRowKeys) {
                 const values = fieldValues[rowKey][triggerId] || [];
                 let condVals = condValues;
                 if (sourceIsVariable) {
@@ -2682,7 +3046,11 @@ function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, s
                         matchedRows.add(rowKey);
                 }
                 else if (detailSymbol === 'UN_EQUAL' || detailSymbol === 'NOT_IN') {
-                    if (values.length && !values.some((v) => condVals.includes(v)))
+                    // 空值即 null（2026-09-22 口径）：null 与任何常量都不相等，也不落在任何 NOT_IN 名单里 ⇒ 条件成立。
+                    // 旧实现额外要求 `values.length`（前提字段必须有值），等于把「字段没填值」当成「条件不成立」，
+                    // 使「未扫描发票（`发票扫描 ≠ "1"`，前提字段通常空着）⇒ 相关流程必填」这类规则在**自然场景下稳定漏报**
+                    // （真机实例见上方主表作用域注释）。注意与 `NULL` / `NOT_NULL` 分工：那两个比较符才是专门判"空/非空"的。
+                    if (!values.some((v) => condVals.includes(v)))
                         matchedRows.add(rowKey);
                 }
                 else {
@@ -2690,6 +3058,14 @@ function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, s
                         matchedRows.add(rowKey);
                 }
             }
+            // 主表条件成立 ⇒ 对所有行放行（它不针对某一明细行）；不成立 ⇒ 空集，AND 时直接把该规则判死。
+            if (mainScope) {
+                const holds = matchedRows.size > 0;
+                matchedRows.clear();
+                if (holds)
+                    for (const key of allRowKeys)
+                        matchedRows.add(key);
+            }
             cdHitSets.push(matchedRows);
         }
         if (!cdHitSets.length)
@@ -2952,19 +3328,110 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
     return result;
 }
 // ---------------------------------------------------------------------------
-// createPrepare / createApply
+// createRequest（合并原 createPrepare + createApply）
 // ---------------------------------------------------------------------------
-async function commandCreatePrepare(args, env) {
+/**
+ * 把 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 **内部**把必填字段的本次取值沉淀为该工作流的偏好（模型无感）。
+ *
+ * 句柄消费时机（关键）：**只在真正要发写入请求之前**消费。缺必填 / 需澄清这类「还没写」的
+ * 返回**不消费**句柄，于是模型补齐字段后可以带**同一个 context** 重发，不必回头重跑 createForm；
+ * 一旦消费，就只能按句柄状态分流（`ALREADY_APPLIED` / 结果不确定 / 并发占用）。
+ */
+async function commandCreateRequest(args, env) {
+    const action = String(args.action ?? '').trim();
+    if (action !== 'draft' && action !== 'submit') {
+        throw workflowValidationError('action_required', 'action 必填，且只能是 draft（仅存草稿）或 submit（提交审批）');
+    }
     const token = String(args.context ?? '');
     if (!token)
         throw workflowValidationError('context_required', '需要 createForm 返回的 continuation（context）');
+    // 只读取载荷、**不消费**：见上方「句柄消费时机」
     const lease = await verifyContextLease(env, token, 'workflow.createForm');
     const context = lease.payload;
     const [main, detailValues] = splitInput(args.data);
     const fields = Array.isArray(context.fields) ? context.fields : [];
     const [entries, fieldAmbiguities] = bindInputFields(main, detailValues, fields);
     if (fieldAmbiguities.length) {
-        return workflowSuccess('workflow.createPrepare', {
+        return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_CONFIRMATION',
             contextId: token,
             message: '存在重名或无法识别的表单字段，请改用字段 id。',
@@ -2973,7 +3440,7 @@ async function commandCreatePrepare(args, env) {
     }
     const readonlyHits = readonlyEntryViolations(entries);
     if (readonlyHits.length) {
-        return workflowSuccess('workflow.createPrepare', {
+        return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_CONFIRMATION',
             contextId: token,
             message: '以下字段是只读/禁止手工编辑字段，不能填写：' + readonlyHits.map((h) => h.name || h.fieldId).join('、'),
@@ -2988,7 +3455,7 @@ async function commandCreatePrepare(args, env) {
     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);
+    const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = 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 || []);
@@ -2996,7 +3463,10 @@ async function commandCreatePrepare(args, env) {
             mh.add(id);
         rowHidden.main = mh;
     }
-    const missing = missingRequiredFields(fields, entries, merged2, hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), new Set(context.layoutSubformIds || []));
+    const hiddenFieldIds = new Set(context.hiddenCellFieldIds || []);
+    const compsFieldIds = new Set(context.compsFieldIds || []);
+    const layoutSubformIds = new Set(context.layoutSubformIds || []);
+    const missing = missingRequiredFields(fields, entries, merged2, hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled, hiddenFieldIds, compsFieldIds, layoutSubformIds);
     const sysPermissions = (context.systemFields && context.systemFields.permissions) || {};
     const sysDefaults = (context.systemFields && context.systemFields.defaults) || {};
     const requestLevelArg = String(args.requestLevel ?? '').trim();
@@ -3013,20 +3483,39 @@ async function commandCreatePrepare(args, env) {
         if (perm.ismandatory && !value)
             systemMissing.push({ key: sysKey, name: SYSTEM_FIELD_KEYS[sysKey], subFormId: '', systemField: true });
     }
-    const intent = String(args.intent ?? 'submit');
-    if (valueAmbiguities.length || ((missing.length || systemMissing.length) && intent !== 'draft')) {
-        return workflowSuccess('workflow.createPrepare', {
-            status: valueAmbiguities.length ? 'NEEDS_CONFIRMATION' : 'NEEDS_INPUT',
+    const linkageResult = linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, hiddenFieldIds, compsFieldIds, entries, layoutSubformIds);
+    // 「显示属性联动」实际命中后新变成必填的字段（rowExtraRequired 就是条件必填的求值结果）。
+    // draft 只做提醒，必须把它们点出来——否则用户拿到的是一份"看着挺完整、提交时才被拦"的草稿。
+    const linkageRequiredIds = new Set();
+    for (const key of Object.keys(rowExtraRequired)) {
+        for (const fieldId of rowExtraRequired[key])
+            linkageRequiredIds.add(String(fieldId));
+    }
+    const missingAll = [...missing, ...systemMissing];
+    if (valueAmbiguities.length) {
+        return workflowSuccess('workflow.createRequest', {
+            status: 'NEEDS_CONFIRMATION',
             contextId: token,
-            message: valueAmbiguities.length ? '存在无法唯一解析的选项，或无法匹配的浏览按钮值，请让用户确认。' : '缺少必填字段。',
+            message: '存在无法唯一解析的选项，或无法匹配的浏览按钮值，请让用户确认。',
             // 已解析成功的字段回显（V12.1.34）：入参给的是名称时，这里给出**服务端最终解析结果**
             // （选项给名称、浏览/人员/部门给 {id,name} 数组），模型据此自查"我传的值到底变成了什么对象"，
-            // 不必把不确定性转嫁给用户确认。READY 时同一内容在 `fields`（确认预览），此处不再重复。
-            // 之前这条短路返回完全没有回显，模型因此抱怨"prepare 输出里看不到字段预览"。
+            // 不必把不确定性转嫁给用户确认。
             resolvedValues: preview,
             ambiguities: valueAmbiguities,
-            missingFields: [...missing, ...systemMissing],
-            linkageResult: linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), entries, new Set(context.layoutSubformIds || [])),
+            missingFields: missingAll,
+            linkageResult,
+            ...folderPayload,
+        });
+    }
+    if (action === 'submit' && missingAll.length) {
+        // submit 且有必填缺失：**不调用创建接口**，把缺失项一次交回给模型/用户
+        return workflowSuccess('workflow.createRequest', {
+            status: 'NEEDS_INPUT',
+            contextId: token,
+            message: '缺少必填字段，本次未发起流程。请把下面这些字段一次问齐后，带同一 context 重发 action=submit。',
+            resolvedValues: preview,
+            missingFields: missingAll,
+            linkageResult,
             ...folderPayload,
         });
     }
@@ -3042,37 +3531,176 @@ async function commandCreatePrepare(args, env) {
         remark: String(args.remark ?? ''),
         preview,
         previewDetails: buildPreviewDetails(preview),
-        intent,
-        missingFields: (intent === 'draft') ? [...missing, ...systemMissing] : [],
+        intent: action,
+        missingFields: missingAll,
         inputFieldIds,
     };
-    const session = await getSessionContext(env);
-    const outToken = await env.continuation.issue({
-        operation: 'workflow.createPrepare',
-        baseUrl: session.baseUrl,
-        profile: session.profile,
-        userId: session.userId,
-        payload: { context, prepared },
-    }, CONTINUATION_TTL_MS);
-    return workflowSuccess('workflow.createPrepare', {
-        status: 'READY',
-        contextId: outToken,
-        requestId: context.runtime.request_id,
+    // ── 以下进入写入路径 ──────────────────────────────────────────────────────
+    // 先把句柄**消费**掉（原子抢占，一次性防重放），再发任何写请求：抢不到说明已有（并发的）
+    // 执行占用该句柄，此时**绝不能写入**，按占用状态给出可执行的处置说明。
+    await verifyContextLease(env, token, 'workflow.createForm', true);
+    // 只读硬拦截兜底：复核本次入参字段此刻是否仍可写
+    if (inputFieldIds.length) {
+        const fieldsById = new Map((context.fields || []).map((f) => [String(f.id ?? ''), f]));
+        const hits = inputFieldIds.filter((fid) => {
+            const f = fieldsById.get(fid);
+            return f && (f.readOnly || f.disableEdit);
+        }).map((fid) => ({ fieldId: fid, name: (fieldsById.get(fid) || {}).name ?? fid }));
+        if (hits.length) {
+            throw workflowPolicyError('field_readonly', '提交数据包含只读/禁止手工编辑字段，已停止保存：' + hits.map((h) => h.name || h.fieldId).join('、'), { notEditable: hits });
+        }
+    }
+    // 保存时字段联动（EVENT_SAVE_DATA）
+    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
+        const saveDetails = prepared.dataDetails || [];
+        const saveEntries = _entriesFromDefaults(saveDetails);
+        if (saveEntries.length) {
+            try {
+                const saveLinkage = await runFieldLinkage(env, linkageContextFromPayload(context), saveEntries, new Set(['EVENT_SAVE_DATA']), saveDetails, false);
+                if (saveLinkage.length)
+                    prepared.dataDetails = mergeLinkageDetails(saveDetails, saveLinkage);
+            }
+            catch {
+                /* 写操作红线：不确定不重试，仅跳过 */
+            }
+        }
+    }
+    // 阶段推进到"要发写入请求了"：此后再被中止/杀掉，重放只能按**结果不确定**处理（先只读核对），
+    // 而在此之前被中止则允许安全重试同一句柄。写不进阶段就中止（宁可不发，也不留无法判定的一次性写入）。
+    await env.continuation.markStage(token, 'saving');
+    let saveData;
+    try {
+        const saveResponse = await env.host.workflowRequest({
+            method: 'POST',
+            path: formApiUrl(FORM_ENDPOINTS.save, context.frame.relate_type),
+            query: { formId: context.layout.form_id, ...AJAX_QUERY },
+            body: buildSaveBody(context, prepared),
+            operation: 'workflow.createRequest',
+        });
+        saveData = parseSaveResponse(saveResponse);
+    }
+    catch (error) {
+        if (isNetworkError(error)) {
+            throw workflowPartialError('saveFormData 请求发送后连接中断，是否已创建不确定，禁止自动重试，请通过 workflow.list 复核', { attempted: { requestId: context.runtime.request_id } }, { stage: 'saveFormData' });
+        }
+        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）
+    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
+        const submitDetails = prepared.dataDetails || [];
+        const submitEntries = _entriesFromDefaults(submitDetails);
+        if (submitEntries.length) {
+            try {
+                const submitLinkage = await runFieldLinkage(env, linkageContextFromPayload(context), submitEntries, new Set(['EVENT_SUBMIT_OR_AGREE']), submitDetails, false);
+                if (submitLinkage.length)
+                    prepared.dataDetails = mergeLinkageDetails(submitDetails, submitLinkage);
+            }
+            catch {
+                /* 跳过 */
+            }
+        }
+    }
+    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),
+            operation: 'workflow.createRequest',
+        });
+        // parseCreateResponse 需读外层 status/code 并向下遍历 data/result，必须传原始响应
+        created = parseCreateResponse(createResponse, context.runtime.request_id);
+        // flow/create 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
+        // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
+        await env.continuation
+            .markStage(token, 'committed', { requestId: context.runtime.request_id })
+            .catch(() => undefined);
+    }
+    catch (error) {
+        if (isNetworkError(error)) {
+            throw workflowPartialError('saveFormData 已成功，但 flow/create 结果失败或不确定；禁止自动重试。', { stage: 'flow/create', ...saveData }, { stage: 'flow/create' });
+        }
+        throw error;
+    }
+    const requestId = context.runtime.request_id;
+    const baseUrl = (await getSessionContext(env)).baseUrl;
+    const result = {
+        status: 'CREATED',
+        message: '流程已创建并保存为草稿。',
+        contextId: token,
+        requestId,
+        requestName: prepared.requestName,
+        requestId_alt: requestId,
+        requestMark: created.requestMark || null,
+        requestName_alt: created.requestName || prepared.requestName,
         workflow: context.workflow,
-        requestName,
-        requestLevel: requestLevelValue,
-        secLevel: secLevelValue,
+        url: `${baseUrl}/sp/workflow/flowpage/view/${requestId}?operResultType=SUCCESS_RELOAD_CURRENT_PAGE&userSpecifiedNodeId=0&autoMaxDisplay=0`,
+        linkageResult,
+        // 缺必填清单**恒有值**（不再"只在 draft 时才有"）：submit 成功时为空数组，draft 时是
+        // 「提交前还需补齐」的提醒。字段恒定存在，模型不需要按 status 分支去猜它有没有。
+        missingFields: missingAll,
+        // 字段落库结果回显：写完之后模型唯一能看到"我填的值到底存成了什么"的地方
+        // （按返回值汇报即可，不必为了核对再查一次流程详情）。
         fields: preview,
-        previewDetails: buildPreviewDetails(preview),
-        confirmationRequired: true,
-        linkageResult: linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden, new Set(context.hiddenCellFieldIds || []), new Set(context.compsFieldIds || []), entries, new Set(context.layoutSubformIds || [])),
-        missingFields: (intent === 'draft') ? [...missing, ...systemMissing] : [],
-        ...folderPayload,
-        message: (!missing.length && !systemMissing.length)
-            ? '尚未调用 saveFormData 和 flow/create。请向用户展示预览并获得明确确认。'
-            : `仅发起保存（draft）模式：以下必填字段未填写：${[...missing, ...systemMissing].map((m) => m.name).join('、')}。可继续 create 保存草稿，或补全字段后重新 prepare。`,
-        continuation: outToken,
-    });
+        previewDetails: prepared.previewDetails,
+    };
+    if (submitIntent) {
+        if (verification.blocked) {
+            result.message = '流程已创建，但因节点字段校验未通过未提交审批，请调整后重新提交。';
+            result.verification = verification;
+        }
+        else if (needConfirm && args.verificationConfirmed !== true) {
+            result.message = '流程已创建，节点字段校验通过。是否继续提交审批？（确认后请告知，将用 submit 命令提交）';
+            result.needVerificationConfirm = true;
+            result.verification = verification;
+            result.nodeId = context.runtime.node_id;
+        }
+        else {
+            result.status = 'CREATED_SUBMITTED';
+            result.message = '流程已发起并提交审批。';
+            result.verification = verification;
+        }
+    }
+    else {
+        // draft：缺失项**只作提醒**（提交前需补齐）；联动后才新出现的必填单独点出来。
+        result.missingFields = missingAll;
+        if (missingAll.length) {
+            const linkageMissed = missingAll.filter((m) => !m.systemField && linkageRequiredIds.has(String(m.id)));
+            result.missingFieldsNotice = '草稿已保存。以下必填字段尚未填写，提交前请补齐：'
+                + missingAll.map((m) => m.name).join('、')
+                + (linkageMissed.length
+                    ? `。其中 ${linkageMissed.map((m) => m.name).join('、')} 是联动后才变成必填的字段（当前所填数据已命中其触发条件）。`
+                    : '。');
+        }
+    }
+    // 必填字段的本次取值 → 该工作流的发起偏好（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) {
     const text = String(value ?? '').trim();
@@ -3309,146 +3937,6 @@ async function runCreateNodeFieldVerification(env, context) {
     result.passed = !result.blocked;
     return result;
 }
-async function commandCreateApply(args, env) {
-    if (args.confirm !== true)
-        throw workflowValidationError('confirm_required', '必须在用户明确确认后传入 confirm=true');
-    const token = String(args.context ?? '');
-    if (!token)
-        throw workflowValidationError('context_required', '需要 createPrepare 返回的 continuation（context）');
-    const lease = await verifyContextLease(env, token, 'workflow.createPrepare', true);
-    const { context, prepared } = lease.payload;
-    // 只读硬拦截兜底：复核 prepare 记录的输入字段此刻是否仍可写
-    const inputIds = prepared.inputFieldIds || [];
-    if (inputIds.length) {
-        const fieldsById = new Map((context.fields || []).map((f) => [String(f.id ?? ''), f]));
-        const readonlyHits = inputIds.filter((fid) => {
-            const f = fieldsById.get(fid);
-            return f && (f.readOnly || f.disableEdit);
-        }).map((fid) => ({ fieldId: fid, name: (fieldsById.get(fid) || {}).name ?? fid }));
-        if (readonlyHits.length) {
-            throw workflowPolicyError('field_readonly', '提交数据包含只读/禁止手工编辑字段，已停止保存：' + readonlyHits.map((h) => h.name || h.fieldId).join('、'), { notEditable: readonlyHits });
-        }
-    }
-    // 保存时字段联动（EVENT_SAVE_DATA）
-    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
-        const saveDetails = prepared.dataDetails || [];
-        const saveEntries = _entriesFromDefaults(saveDetails);
-        if (saveEntries.length) {
-            try {
-                const saveLinkage = await runFieldLinkage(env, linkageContextFromPayload(context), saveEntries, new Set(['EVENT_SAVE_DATA']), saveDetails, false);
-                if (saveLinkage.length)
-                    prepared.dataDetails = mergeLinkageDetails(saveDetails, saveLinkage);
-            }
-            catch {
-                /* 写操作红线：不确定不重试，仅跳过 */
-            }
-        }
-    }
-    // 阶段推进到"要发写入请求了"：此后再被中止/杀掉，重放只能按**结果不确定**处理（先只读核对），
-    // 而在此之前被中止则允许安全重试同一句柄。写不进阶段就中止（宁可不发，也不留无法判定的一次性写入）。
-    await env.continuation.markStage(token, 'saving');
-    let saveData;
-    try {
-        const saveResponse = await env.host.workflowRequest({
-            method: 'POST',
-            path: formApiUrl(FORM_ENDPOINTS.save, context.frame.relate_type),
-            query: { formId: context.layout.form_id, ...AJAX_QUERY },
-            body: buildSaveBody(context, prepared),
-            operation: 'workflow.createApply',
-        });
-        saveData = parseSaveResponse(saveResponse);
-    }
-    catch (error) {
-        if (isNetworkError(error)) {
-            throw workflowPartialError('saveFormData 请求发送后连接中断，是否已创建不确定，禁止自动重试，请通过 workflow.list 复核', { attempted: { requestId: context.runtime.request_id } }, { stage: 'saveFormData' });
-        }
-        throw error;
-    }
-    const submitIntent = String(args.intent ?? 'submit') === '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）
-    if (Array.isArray(context.linkageActions) && context.linkageActions.length) {
-        const submitDetails = prepared.dataDetails || [];
-        const submitEntries = _entriesFromDefaults(submitDetails);
-        if (submitEntries.length) {
-            try {
-                const submitLinkage = await runFieldLinkage(env, linkageContextFromPayload(context), submitEntries, new Set(['EVENT_SUBMIT_OR_AGREE']), submitDetails, false);
-                if (submitLinkage.length)
-                    prepared.dataDetails = mergeLinkageDetails(submitDetails, submitLinkage);
-            }
-            catch {
-                /* 跳过 */
-            }
-        }
-    }
-    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),
-            operation: 'workflow.createApply',
-        });
-        // parseCreateResponse 需读外层 status/code 并向下遍历 data/result，必须传原始响应
-        created = parseCreateResponse(createResponse, context.runtime.request_id);
-        // flow/create 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
-        // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
-        await env.continuation
-            .markStage(token, 'committed', { requestId: context.runtime.request_id })
-            .catch(() => undefined);
-    }
-    catch (error) {
-        if (isNetworkError(error)) {
-            throw workflowPartialError('saveFormData 已成功，但 flow/create 结果失败或不确定；禁止自动重试。', { stage: 'flow/create', ...saveData }, { stage: 'flow/create' });
-        }
-        throw error;
-    }
-    const requestId = context.runtime.request_id;
-    const requestName = prepared.requestName;
-    const baseUrl = (await getSessionContext(env)).baseUrl;
-    const result = {
-        status: 'CREATED',
-        message: '流程已创建并保存为草稿。',
-        contextId: token,
-        requestId,
-        requestName,
-        requestId_alt: requestId,
-        requestMark: created.requestMark || null,
-        requestName_alt: created.requestName || requestName,
-        workflow: context.workflow,
-        url: `${baseUrl}/sp/workflow/flowpage/view/${requestId}?operResultType=SUCCESS_RELOAD_CURRENT_PAGE&userSpecifiedNodeId=0&autoMaxDisplay=0`,
-    };
-    if (submitIntent) {
-        if (verification.blocked) {
-            result.status = 'CREATED';
-            result.message = '流程已创建，但因节点字段校验未通过未提交审批，请调整后重新提交。';
-            result.verification = verification;
-        }
-        else if (needConfirm && args.verificationConfirmed !== true) {
-            result.status = 'CREATED';
-            result.message = '流程已创建，节点字段校验通过。是否继续提交审批？（确认后请告知，将用 submit 命令提交）';
-            result.needVerificationConfirm = true;
-            result.verification = verification;
-            result.nodeId = context.runtime.node_id;
-        }
-        else {
-            result.status = 'CREATED_SUBMITTED';
-            result.message = '流程已发起并提交审批。';
-            result.verification = verification;
-        }
-    }
-    return workflowSuccess('workflow.createApply', result);
-}
 // ---------------------------------------------------------------------------
 // editLoad / editPrepare / editSave
 // ---------------------------------------------------------------------------
@@ -3805,7 +4293,7 @@ async function commandEditPrepare(args, env) {
     const merged2 = mergeLinkageDetails(merged, linkageDetails);
     const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
     const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
-    const [hiddenSubforms, rowHidden, , rowDisabled] = computeLinkageVisibility(context.viewLinkages, entries, context.currentDetails || [], linkageDetails, context.systemFieldValues);
+    const [hiddenSubforms, rowHidden, , rowDisabled] = computeLinkageVisibility(context.viewLinkages, entries, context.currentDetails || [], linkageDetails, context.systemFieldValues, fields);
     const previewAll = [...preview];
     const fieldsById = new Map();
     for (const f of fields)
@@ -3896,7 +4384,7 @@ async function commandEditSave(args, env) {
         }
     }
     // 阶段推进到"要发写入请求了"：此后再被中止/杀掉，重放只能按**结果不确定**处理（先只读核对），
-    // 而在此之前被中止则允许安全重试同一句柄（与 createApply 对称）。
+    // 而在此之前被中止则允许安全重试同一句柄（与 createRequest 对称）。
     await env.continuation.markStage(token, 'saving');
     let data;
     try {
@@ -3936,122 +4424,6 @@ async function commandEditSave(args, env) {
         saveLinkage: Boolean(resolvePrepared(context, prepared).dataDetails?.length),
     });
 }
-// ---------------------------------------------------------------------------
-// createList（查询可发起工作流）
-// ---------------------------------------------------------------------------
-/**
- * `createList` 大输出保护。
- *
- * 未传 `name` / `workflowId` 时本命令返回**当前用户全部可发起工作流**，流程多的租户动辄数千个
- * （线上实测某租户 3,862 个、美化后约 460 KB），远超宿主的单次输出线（≈28 KB）⇒ 会被截成
- * 2048 B 预览，模型只能自己写脚本去读文件（线上会话即如此绕行）。
- *
- * 对齐同文件的 `compactFormOutput` 与 `read.ts` 的 `enforceSearchStdoutBudget`：超安全线时把
- * 完整清单落盘，stdout 只保留前 `CREATE_LIST_INLINE_LIMIT` 条，并在**最前面**给出 `resultFile`
- * （被截断也看得见）；落盘不可用时保持全量（宁大不丢数据），只补一句说明。
- *
- * 注意：本命令的 `SELECTED`（1 条）/ `NOT_FOUND`（0 条）分支体积天然很小，无需过此函数。
- */
-const CREATE_LIST_INLINE_LIMIT = 100;
-async function compactCreateListOutput(payload, env) {
-    const bytes = stdoutBytesOf(payload);
-    if (bytes <= STDOUT_SAFE_BYTES)
-        return payload;
-    const workflows = toArray(payload.workflows);
-    const resultFile = await writeStateFileBestEffort('last_create_list.json', JSON.stringify(payload, null, 2), env.ctx);
-    if (!resultFile) {
-        return {
-            ...payload,
-            outputBytes: bytes,
-            largeOutputNotice: `可发起工作流较多（${workflows.length} 个）且本地落盘不可用，已按原样返回全量 workflows。`
-                + '请改用 name 或 workflowId 精确定位，不要整份读入上下文。',
-        };
-    }
-    return withLeadingMeta({
-        resultFile,
-        persistedResult: true,
-        outputBytes: bytes,
-        workflowsTotal: workflows.length,
-        workflowsTruncated: true,
-        largeOutputNotice: `可发起工作流较多（${workflows.length} 个），完整清单已写入 resultFile；`
-            + `stdout 只保留前 ${CREATE_LIST_INLINE_LIMIT} 条。`
-            + '需要更多候选时从 resultFile 按需提取（不要整份读入上下文）——更推荐直接传 `name`（按名称匹配）'
-            + '或 `workflowId`（精确校验）来定位，避免拉全量。读取本输出请一次读完，不要用 head/tail 截断。',
-    }, {
-        ...payload,
-        workflows: workflows.slice(0, CREATE_LIST_INLINE_LIMIT),
-    });
-}
-async function commandCreateList(args, env) {
-    const workflowId = String(args.workflowId ?? '').trim();
-    const name = String(args.name ?? '').trim();
-    // `name` 与 `workflowId` 都不传时**直接返回提示、不发请求**：这种调用（线上会话出现过
-    // `--input-json '{}'`）只会拿到当前用户的全部可发起工作流（线上实测 3,862 条），既定位不到
-    // 用户要的流程，体积也必然超输出线 —— 与其拉下来再落盘/截断兜底，不如根本不发这一次请求。
-    if (!workflowId && !name) {
-        return workflowSuccess('workflow.createList', {
-            status: 'MISSING_QUERY',
-            message: '未提供 name 或 workflowId，已跳过查询。不传这两个参数时只能拉取当前用户的全部可发起工作流，'
-                + '既无法定位到用户要的流程、体积也远超单次输出上限。'
-                + '请先用业务流程名称（name）做模糊匹配，或直接传已知的 workflowId 做精确校验。',
-            workflows: [],
-        });
-    }
-    const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, { wfpBelongTypeCode: '1', loadOfsFlow: '0', clientCtrl: 1 });
-    // requestJson 内部已解包一层（responseData），此处不可再取 .data
-    const data = (response && typeof response === 'object') ? response : null;
-    if (!data || typeof data !== 'object')
-        throw workflowApiError('format_error', '工作流列表返回 data 格式错误');
-    if (workflowId) {
-        const authorized = simplifyWorkflows(data);
-        const exact = authorized.filter((item) => String(item.id ?? '').trim() === workflowId);
-        if (exact.length) {
-            return workflowSuccess('workflow.createList', {
-                status: 'SELECTED',
-                workflow: exact[0],
-                selectionSource: 'workflowId',
-                message: '已按记忆中的 workflowId 精确确认可发起工作流，无需用户选择。',
-            });
-        }
-        return workflowSuccess('workflow.createList', {
-            status: 'NOT_FOUND',
-            query: name,
-            workflowId,
-            message: '记忆中的 workflowId 不在当前用户可发起工作流列表中，可能已无发起权限或工作流已停用。',
-            workflows: [],
-        });
-    }
-    const result = simplifyWorkflows(data, name);
-    if (!result.length) {
-        return workflowSuccess('workflow.createList', { status: 'NOT_FOUND', query: name, workflows: [] });
-    }
-    if (result.length === 1) {
-        return workflowSuccess('workflow.createList', { status: 'SELECTED', workflow: result[0] });
-    }
-    // 多命中时**先按全名精确匹配优选**：候选里恰好有一个名字与用户所写完全相同的（如"总部费用报销"
-    // 对上「总部费用报销 / 总部费用报销流程 / 总部费用报销（自定义）」），就直接选中它，不让用户
-    // 为"是不是要多打几个字"再选一次。这与查询侧 `resolveTerm` 的候选优选是**同一套判据**。
-    // 只有在"没有任何候选与所写完全一致"（或完全一致的有多个、仍是歧义）时才请用户选择。
-    const keyword = name.toLowerCase();
-    const exact = keyword
-        ? result.filter((item) => String(item.workflowname ?? '').trim().toLowerCase() === keyword)
-        : [];
-    if (exact.length === 1) {
-        return workflowSuccess('workflow.createList', {
-            status: 'SELECTED',
-            workflow: exact[0],
-            selectionSource: 'exactName',
-            message: `名称与「${name}」完全一致的工作流只有 1 个，已直接选中，无需用户选择。`,
-        });
-    }
-    const selected = exact.length ? exact : result;
-    return workflowSuccess('workflow.createList', await compactCreateListOutput({
-        status: 'NEEDS_SELECTION',
-        message: '匹配到多个工作流，且其中没有与所写名称完全一致的，请让用户选择后再继续。',
-        query: name,
-        workflows: selected,
-    }, env));
-}
 function simplifyWorkflows(data, name = '') {
     const groups = Array.isArray(data.listDataGroup) ? data.listDataGroup : [];
     const typeNames = {};
@@ -4086,44 +4458,33 @@ function simplifyWorkflows(data, name = '') {
 // ---------------------------------------------------------------------------
 // operation 定义
 // ---------------------------------------------------------------------------
-const workflowCreateList = {
-    name: 'workflow.createList',
-    resource: 'workflow',
-    method: 'createList',
-    action: 'workflow.createList',
-    summary: '查询当前用户可发起的工作流列表（按名称或记忆 workflowId 精确确认）',
-    capability: 'create',
-    risk: 'read',
-    requiresConfirmation: false,
-    inputSchema: schemaOf({
-        name: { type: 'string', description: '工作流名称关键字（模糊匹配）。**与 workflowId 至少传一个**——两个都不传时本命令不做查询，直接返回 status=MISSING_QUERY 的提示（不传参数只能拉取全部可发起工作流，无法定位用户要的流程）' },
-        workflowId: { type: 'string', description: '记忆中已确认的工作流 ID；传入时按当前用户可发起列表精确校验并优先选中。**与 name 至少传一个**' },
-    }, { required: [] }),
-    handler: (args, env) => commandCreateList(args, env),
-};
 const workflowCreateForm = {
     name: 'workflow.createForm',
     resource: 'workflow',
     method: 'createForm',
     action: 'workflow.createForm',
-    summary: '初始化发起流程表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出字段清单 + fileUploadParams（不落业务数据）',
+    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好（不落业务数据）',
     capability: 'create',
     risk: 'read',
     requiresConfirmation: false,
     inputSchema: schemaOf({
-        workflowId: SCHEMA_REQUEST_ID,
+        workflow: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用英文逗号分隔，如 "报销,报销流程")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；0 命中或多命中且无全名精确匹配时返回澄清（候选见 candidates），确认后用「名称(ID)」重发',
+        },
         relatesTo: { type: 'string', description: '可选关联对象 id（仅透传，不影响表单初始化）' },
-    }, { required: ['workflowId'] }),
+    }, { required: ['workflow'] }),
     handler: (args, env) => commandCreateForm(args, env),
 };
-const workflowCreatePrepare = {
-    name: 'workflow.createPrepare',
+const workflowCreateRequest = {
+    name: 'workflow.createRequest',
     resource: 'workflow',
-    method: 'createPrepare',
-    action: 'workflow.createPrepare',
-    summary: '收集并准备表单数据：绑定字段、解析选项/浏览按钮、校验只读字段、触发字段联动，产出确认预览 + continuation（不落业务数据）',
+    method: 'createRequest',
+    action: 'workflow.createRequest',
+    summary: '按 action 一次完成发起：绑定字段 → 解析选项/浏览按钮 → 触发字段联动与显示属性联动 → 必填校验 →（submit 缺必填则只回报缺失、不写）→ saveFormData → flow/create',
     capability: 'create',
-    risk: 'read-before-write',
+    risk: 'high-risk-write',
     requiresConfirmation: true,
     inputSchema: schemaOf({
         context: SCHEMA_CONTINUATION,
@@ -4132,31 +4493,14 @@ const workflowCreatePrepare = {
             description: '表单字段值，结构 {"main":{...},"details":{"<subFormId>":[{...}]}}',
             additionalProperties: true,
         },
+        action: { type: 'string', enum: ['draft', 'submit'], description: 'draft=仅保存草稿（必填缺失不阻断，缺失项随结果作为提醒返回）；submit=提交审批（仍有必填缺失时不调用创建接口，改为一次性回报全部缺失项）' },
         requestName: { type: 'string', description: '流程标题（form 返回 requestName 非空时直接用其值；为空时由模型按内容生成）' },
         requestLevel: { type: 'string', description: '紧急程度（取 systemFields.levelOptions 的 code）' },
         secLevel: { type: 'string', description: '密级（取 systemFields.secLevelOptions 的 id）' },
         remark: { type: 'string', description: '签字意见' },
-        intent: { type: 'string', enum: ['submit', 'draft'], description: '意图：submit=提交审批（必填缺失阻断）；draft=仅保存草稿（必填缺失不阻断）' },
-    }, { required: ['context', 'data', 'intent'] }),
-    handler: (args, env) => commandCreatePrepare(args, env),
-};
-const workflowCreateApply = {
-    name: 'workflow.createApply',
-    resource: 'workflow',
-    method: 'createApply',
-    action: 'workflow.createApply',
-    summary: '明确确认后发起流程：写前复核只读字段 → build_save_body → fdLinkage → saveFormData → flow/create；结果不确定抛 partial error 禁止重试',
-    capability: 'create',
-    risk: 'high-risk-write',
-    requiresConfirmation: true,
-    inputSchema: schemaOf({
-        context: SCHEMA_CONTINUATION,
-        confirm: SCHEMA_CONFIRM,
-        intent: { type: 'string', enum: ['submit', 'draft'], description: '意图（必填，独立于 prepare 的 intent）：submit=创建并提交审批；draft=仅保存草稿' },
-        question: { type: 'string', description: '用户发起时的原话（记忆保存参考）' },
         verificationConfirmed: { type: 'boolean', description: '节点字段校验需用户确认时显式确认继续提交' },
-    }, { required: ['context', 'confirm', 'intent'] }),
-    handler: (args, env) => commandCreateApply(args, env),
+    }, { required: ['context', 'data', 'action'] }),
+    handler: (args, env) => commandCreateRequest(args, env),
 };
 const workflowEditLoad = {
     name: 'workflow.editLoad',
@@ -4205,10 +4549,8 @@ const workflowEditApply = {
     handler: (args, env) => commandEditSave(args, env),
 };
 export const workflowFormOperations = [
-    workflowCreateList,
     workflowCreateForm,
-    workflowCreatePrepare,
-    workflowCreateApply,
+    workflowCreateRequest,
     workflowEditLoad,
     workflowEditPrepare,
     workflowEditApply,