weaver-work-cli 0.1.25 → 0.1.28

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

@@ -20,11 +20,13 @@ import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CONTINUATION, SCHE
 import { asBool, responseData, toArray, withLeadingMeta, stdoutBytesOf, stdoutCharsOf, STDOUT_SAFE_BYTES, parseNameWithId, resolveMemoryAppId, } from './shared.js';
 import { workflowValidationError, workflowApiError, workflowPartialError, workflowPolicyError, workflowClarificationError, WorkflowCliError, } from '../errors.js';
 import { FORM_ENDPOINTS, WORKFLOW_ENDPOINTS, AJAX_QUERY, formApiUrl } from '../endpoints.js';
+import { resolveSignRemark } from './sign-input.js';
 import { compactStdoutPaths } from '../stdout-compact.js';
 import { continuationReplayError } from '../continuation.js';
 import { writeStateFileBestEffort } from '../state.js';
-import { buildHistoryRequestData, fetchHistoryListSnapshot, filterHistoryRequestData } from './read.js';
+import { buildHistoryRequestData, fetchHistoryListSnapshot, filterHistoryRequestData, pickUniqueMineWorkflow } from './read.js';
 import { hasXiaoEEnv } from '../../../internal/e10/auth/xiaoe.js';
+import { buildChatSceneInput, formatLocalNow, requestFormFill } from './chatscene.js';
 // ---------------------------------------------------------------------------
 // 常量（与 Python 源逐条对齐）
 // ---------------------------------------------------------------------------
@@ -1217,6 +1219,86 @@ function collectHiddenMultiContentFieldIds(comps) {
     }
     return hiddenFieldIds;
 }
+/**
+ * 页面根网格（Sheet1）上**被隐藏的单元格**里的字段（2026-10-20 修复）。
+ *
+ * `pageLayouts[0].config.workbook.Sheet1.cells[]` 里 `cell.tag.attrs.hide === true`
+ * ⇒ 该单元格（`col:row`）在表单上不显示，格子里的字段用户看不到。
+ *
+ * 寻址必须**沿容器链往上走**（与隐藏行 / 隐藏列 / 多内容格同一套）：组件的 `config.excel.col`/`row`
+ * 是**相对其父容器**的坐标，只有 `excel.parent === 'ROOT'` 那一层才是 Sheet1 的行列号。
+ * 真机反例（总部费用报销，「报销人直接上级」`fieldId 100003720000076596`）：字段自身的坐标是
+ * `col:0,row:0`（相对它所在的 `MultiContent` 容器），真正被藏起来的是 Sheet1 上 `col:3,row:4`
+ * 那个格子里的**容器本体**——只比字段自己的坐标就永远不可能命中，值于是漏进「已填内容」。
+ *
+ * 之前这里的实现只拿 comp 自己的 `excel.col:row` 与 Sheet1 的隐藏格直接比对，组合控件（尤其是
+ * `MultiContent`）内部的字段一概漏判；改成沿链上溯后，容器被藏 ⇒ 它内部所有字段一并判隐藏。
+ *
+ * 查不到 `cells` / 没有隐藏格时**不判隐藏**——fail-open，与其它隐藏口径同一降级原则。
+ */
+function collectHiddenSheetCellFieldIds(page0, comps) {
+    const hiddenFieldIds = new Set();
+    const sheet1 = page0?.config?.workbook?.Sheet1;
+    const cells = sheet1 && Array.isArray(sheet1.cells) ? sheet1.cells : [];
+    if (!cells.length)
+        return hiddenFieldIds;
+    /** `col:row`（两边同口径归一成数字，避免 `"3"` 与 `3` 对不上）；坐标不可解析时返回 null。 */
+    const posOf = (col, row) => {
+        const c = Number(col);
+        const r = Number(row);
+        if (!Number.isFinite(c) || !Number.isFinite(r))
+            return null;
+        return `${c}:${r}`;
+    };
+    const hidePositions = new Set();
+    for (const cell of cells) {
+        if (!cell || typeof cell !== 'object')
+            continue;
+        const attrs = cell.tag?.attrs;
+        if (!attrs || typeof attrs !== 'object' || !attrs.hide)
+            continue;
+        const pos = posOf(cell.col, cell.row);
+        if (pos)
+            hidePositions.add(pos);
+    }
+    if (!hidePositions.size)
+        return hiddenFieldIds;
+    // nodeId → 组件：组件的 `excel.parent` 指向父容器的 nodeId，靠它才能找回父容器自己的坐标。
+    const compByNodeId = new Map();
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const nodeId = String(comp.config?.excel?.nodeId ?? '').trim();
+        if (nodeId)
+            compByNodeId.set(nodeId, comp);
+    }
+    for (const comp of toArray(comps)) {
+        if (!comp || typeof comp !== 'object')
+            continue;
+        const fieldId = String(comp.config?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        let cursor = comp;
+        while (cursor) {
+            const excel = cursor.config?.excel;
+            if (!excel || typeof excel !== 'object')
+                break;
+            const parentId = String(excel.parent ?? '').trim();
+            if (!parentId || parentId === 'ROOT') {
+                // 到根网格这一层才是 Sheet1 的真实行列号（容器内的坐标是相对的，比不得）。
+                const pos = posOf(excel.col, excel.row);
+                if (pos && hidePositions.has(pos))
+                    hiddenFieldIds.add(fieldId);
+                break;
+            }
+            const owner = compByNodeId.get(parentId);
+            if (!owner)
+                break;
+            cursor = owner;
+        }
+    }
+    return hiddenFieldIds;
+}
 function parseLayoutMeta(layoutData) {
     const hiddenCellIds = new Set();
     const compsFieldIds = new Set();
@@ -1226,44 +1308,6 @@ function parseLayoutMeta(layoutData) {
     if (Array.isArray(pageLayouts) && pageLayouts.length)
         page0 = pageLayouts[0];
     if (page0 && typeof page0 === 'object') {
-        const wb = page0.config && page0.config.workbook ? page0.config.workbook : {};
-        const sheet1 = wb.Sheet1;
-        const cells = sheet1 ? sheet1.cells : null;
-        const hidePositions = new Set();
-        if (Array.isArray(cells)) {
-            for (const cell of cells) {
-                if (!cell || typeof cell !== 'object')
-                    continue;
-                const attrs = cell.tag && cell.tag.attrs ? cell.tag.attrs : {};
-                if (attrs.hide) {
-                    try {
-                        hidePositions.add(`${cell.col}:${cell.row}`);
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            }
-        }
-        if (hidePositions.size) {
-            for (const comp of page0.comps || []) {
-                if (!comp || typeof comp !== 'object')
-                    continue;
-                const cfg = comp.config || {};
-                const fid = String(cfg.fieldId ?? '').trim();
-                if (!fid)
-                    continue;
-                const excel = cfg.excel || {};
-                try {
-                    const pos = `${excel.col}:${excel.row}`;
-                    if (hidePositions.has(pos))
-                        hiddenCellIds.add(fid);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-        }
         for (const comp of page0.comps || []) {
             if (!comp || typeof comp !== 'object')
                 continue;
@@ -1280,6 +1324,9 @@ function parseLayoutMeta(layoutData) {
         // 行隐藏 / 单元格隐藏 / 明细表隐藏列 / 多内容单元格隐藏**同义**（都是"用户在表单上看不到"），
         // 并成一份 `hiddenCellIds`：下游 `visibleFields`/`initialValue`/`missingRequiredFields`/「已填内容」
         // /联动提示全部只认这一份，且随句柄以 `hiddenCellFieldIds` 传给 `createRequest`，两边口径天然一致。
+        // 单元格隐藏**必须沿容器链上溯**（2026-10-20 修复）：容器的 `excel` 坐标才是 Sheet1 上的位置。
+        for (const fid of collectHiddenSheetCellFieldIds(page0, page0.comps))
+            hiddenCellIds.add(fid);
         for (const fid of collectHiddenRowFieldIds(page0, page0.comps))
             hiddenCellIds.add(fid);
         for (const fid of collectHiddenDetailColumnFieldIds(page0, page0.comps))
@@ -1349,17 +1396,29 @@ function requiredInfoWarningText(context) {
 // 发起侧工作流解析（原 createList 的职责；候选池 = 当前用户「可发起的工作流」）
 // ---------------------------------------------------------------------------
 /**
- * 把一个「纯名称」切成多个匹配关键词（2026-09-23 用户裁定）。
+ * 名称关键词的**填充词**（按长词优先依次脱壳）。
+ *
+ * 用户裁定：「去掉一些词：工作流、流程」（2026-09-23）；「现在要**额外去掉申请**关键字」
+ * （2026-10-21）。顺序有讲究：`工作流程` 必须排在 `工作流` / `流程` 之前
+ * （`工作流` 与 `流程` 在 `流` 处重叠，先剥短的会漏判）。
+ */
+const CREATE_KEYWORD_FILLERS = ['工作流程', '工作流', '流程', '申请'];
+/**
+ * 把一个「纯名称」切成多个名称关键词（2026-09-23 用户裁定 + 2026-10-21 追加净词）。
  *
  * 单个格内可用逗号分隔多个关键词（中英文逗号都认），也可用数组多元素表达；命中结果做**并集**，
- * 目的是**提高候选召回** —— 用户首次要发起某个流程时，多给几个说法更容易命中他真正要发起的那个，
- * 从而少让用户回来补全名称。
- *
- * 去词规则（用户裁定，逐字）：「**去掉一些词：工作流、流程**」。落到实现上是——
- * **只丢弃"整格就是填充词"的关键词**（`流程` / `工作流` / `工作流程`），其余**原样保留**：
- * - `"报销,报销流程,流程"` → 关键词 = `报销`、`报销流程`（**两个**，`流程` 被丢掉）；
- * - `报销流程` **不在词内剥离** —— 它是有效关键词（剥成 `报销` 会让"多关键词"退化成单关键词）。
- * 匹配不到的关键词在并集里自然贡献为空，无害，所以不必额外清理。
+ * 目的是**提高候选召回** —— 用户首次要发起某个流程时，多给几个说法更容易命中他真正要发起的那个。
+ *
+ * 每个关键词带**两副面孔**（2026-10-21 用户裁定）：
+ * - `raw` = 原样（`请假流程`、`请假申请`）；
+ * - `core` = 去掉填充词后的净词（`请假流程` → `请假`、`请假申请` → `请假`、`总部请假` → `总部请假`）。
+ *
+ * 两者**都参与本地模糊过滤**（候选取并集），于是「请假申请」既按它自己、也按「请假」去找，
+ * 能命中「请假申请单」这类名字；净词与原词相同的词天然只算一次。
+ *
+ * **只丢弃"整格全是填充词"的关键词**（`流程` / `工作流` / `申请` …）：它们不代表任何业务含义，
+ * 留着会命中一大批无关流程。`报销申请` 这类**含填充词但本身有效**的词不会被丢 ——
+ * 它的净词 `报销` 才是干活的那个。
  */
 function splitCreateKeywords(raw) {
     const out = [];
@@ -1368,15 +1427,18 @@ function splitCreateKeywords(raw) {
         const token = piece.trim();
         if (!token)
             continue;
-        // 填充词按**长词优先**脱壳：`工作流程` → 空（`工作流`+`流程` 在 `流` 处重叠，顺序错会漏判）
-        const residue = token.split('工作流程').join('').split('工作流').join('').split('流程').join('');
-        if (!residue.trim())
+        let core = token;
+        for (const filler of CREATE_KEYWORD_FILLERS)
+            core = core.split(filler).join('');
+        core = core.trim();
+        // 整格都是填充词 ⇒ 丢弃（留着会让 `流程` 命中「请假流程」「合同流程」等一大批）
+        if (!core)
             continue;
         const key = token.toLowerCase();
         if (seen.has(key))
             continue;
         seen.add(key);
-        out.push(token);
+        out.push({ raw: token, core });
     }
     return out;
 }
@@ -1390,10 +1452,17 @@ function splitCreateKeywords(raw) {
  * - **0 命中 → 澄清**：不能把「没听懂你的条件」伪装成「没有这条流程」，否则模型会如实转述成
  *   "没有该工作流"，用户拿不到可操作的信息；
  * - 1 命中 → 直接用；
- * - 多命中但候选中**恰有一个与所写名称完全一致** → 直接用，不为"要不要多打几个字"再问一次；
- * - 多命中且没有完全一致的 → 澄清并列出候选（`display` 即 `名称(ID)`，用户选定后原样回传）。
+ * - 多命中时，**全名一致必须唯一**才直接用（2026-10-21 用户二次裁定，撤销同日"按词序先到先得"）：
+ *   连"净词 + 原词"一起算，若与候选全名一致的说法只指向**同一个**候选 ⇒ 用它；若指向**多个不同**
+ *   候选（如 `费用报销,报销流程审批` 恰好各自对上一条）⇒ 这是用户给的条件本身有歧义，仍回来澄清；
+ * - 多命中且没有任何全名一致的 → 澄清并列出候选（`display` 即 `名称(ID)`，用户选定后原样回传）。
+ *   这一档在澄清**之前**先做一次消歧（2026-10-20 用户裁定）：把候选拿去查「我发起的」工作流树，
+ *   用户近一年只发起过其中**一个**就直接用它（`from:'mineRecentUnique'`）；否则/失败则照旧澄清。
+ *   **只有这一档会消歧**：0 命中、以及"只给了填充词"那两档都不查（前者本就没候选可比，
+ *   后者在发任何远端请求前就澄清了）。
  *
- * 名称格支持**多关键词**（`"报销,报销流程"`，见 `splitCreateKeywords`）：各关键词命中做并集去重后，
+ * 名称格支持**多关键词**（`"报销,报销流程"`，见 `splitCreateKeywords`）：每个关键词同时贡献
+ * **净词**与**原词**（`请假申请` → `请假` + `请假申请`），两组词各自命中后**并集去重**，
  * 再走上面同一套判据。**只发一次** `getNewFlowListData` 而不是每个关键词并行各发一次 —— 该接口
  * 请求体固定为 `{wfpBelongTypeCode, loadOfsFlow, clientCtrl}`、**没有任何关键词入参**（V11.3 Python
  * 基线 `e10_workflow_create.py:395-436` 同样是取全量后本地过滤；真机单笔 ≈1,649 ms / 228,929 B），
@@ -1416,8 +1485,17 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
     // 一个关键词都没解析出来（如只传了 `流程`）时**连可发起列表都不去拉**
     // （该接口真机单笔 ≈1,649 ms / 228,929 B），与"完全不传 workflow"同一口径。
     const explicitIds = new Set();
-    const nameTerms = [];
-    const keywordSeen = new Set();
+    /** 参与**本地模糊过滤**的词：每个关键词先净词、再原词（同一词只留一个）。 */
+    const filterTerms = [];
+    /**
+     * 参与**全名精确匹配**的词集合：每个关键词先净词、再原词（如 `请假申请` → `请假` + `请假申请`）。
+     *
+     * 只做集合比对、**不看先后次序**（2026-10-21 二次裁定：全名一致必须唯一才直接用，不允许按词序
+     * 先到先得）。
+     */
+    const exactTerms = [];
+    const filterSeen = new Set();
+    const exactSeen = new Set();
     for (const term of rawTerms) {
         const parsed = parseNameWithId(term);
         // 纯数字同样按 ID 处理（`parseNameWithId` 只认 "名称(数字)" 形态）
@@ -1427,14 +1505,29 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
             continue;
         }
         for (const keyword of splitCreateKeywords(parsed.name)) {
-            const key = keyword.toLowerCase();
-            if (keywordSeen.has(key))
-                continue;
-            keywordSeen.add(key);
-            nameTerms.push(keyword);
+            const coreKey = keyword.core.toLowerCase();
+            const rawKey = keyword.raw.toLowerCase();
+            // 模糊过滤：**单字净词不参与**（`申请单` 剥成 `单` 会把整张清单拉进来）；
+            // 原词永远参与，所以"只说得出一个怪名字"时召回不受影响。
+            if (keyword.core.length >= 2 && !filterSeen.has(coreKey)) {
+                filterSeen.add(coreKey);
+                filterTerms.push(keyword.core);
+            }
+            if (!filterSeen.has(rawKey)) {
+                filterSeen.add(rawKey);
+                filterTerms.push(keyword.raw);
+            }
+            if (!exactSeen.has(coreKey)) {
+                exactSeen.add(coreKey);
+                exactTerms.push(keyword.core);
+            }
+            if (!exactSeen.has(rawKey)) {
+                exactSeen.add(rawKey);
+                exactTerms.push(keyword.raw);
+            }
         }
     }
-    if (!explicitIds.size && !nameTerms.length) {
+    if (!explicitIds.size && !filterTerms.length) {
         throw workflowClarificationError('workflow', queryText, '要发起哪个流程？请提供该流程的完整名称（或其它可用于检索的关键词）后再继续。');
     }
     const response = await requestJson(env, 'POST', FORM_ENDPOINTS.workflowCreateList, AJAX_QUERY, {
@@ -1455,7 +1548,7 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
         }
     }
     // 名称关键词：逐个取命中，**并集去重**（多给几个说法只扩大候选面，不改变下面的命中判据）
-    for (const keyword of nameTerms) {
+    for (const keyword of filterTerms) {
         for (const item of simplifyWorkflows(data, keyword)) {
             if (seen.has(String(item.id)))
                 continue;
@@ -1470,13 +1563,30 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
         return { id, name: String(only.workflowname ?? ''), source: explicitIds.has(id) ? 'workflowId' : 'single' };
     }
     if (picked.length > 1) {
-        const wanted = new Set(nameTerms.map((t) => t.trim().toLowerCase()).filter(Boolean));
+        // ★ 2026-10-21 用户二次裁定：**退回「全名命中必须唯一」**——同日早先那版"按词序循环、第一个
+        // 全名一致的就用"已撤销。理由：多个说法各自全名命中**不同**候选时，用户给的条件本身就有歧义
+        // （两条互相竞争的精确证据），按词序替用户先到先得等于擅自替他裁决，宁可回来问一句。
+        //
+        // 仍算"唯一"、可直接用的两档：
+        // - 只有一个候选与某个说法全名一致，其余说法只是陪跑（命中的是别的、或没命中）；
+        // - 多个说法全名命中的是**同一个**候选（去重后仍是一条）。
+        // "说法"包含每个关键词的**净词**与**原词**（见 `exactTerms`），两者都参与比对。
+        //
+        // 某个说法命中**多条同名候选**（不同 id、名字一字不差）同样算不唯一 ⇒ 一并澄清。
+        const wanted = new Set(exactTerms.map((t) => t.trim().toLowerCase()).filter(Boolean));
         const exact = picked.filter((item) => wanted.has(String(item.workflowname ?? '').trim().toLowerCase()));
-        // 多命中时有唯一全名精确匹配 → 直接选中（与查询侧 exact_candidates 优选同一判据）
         if (exact.length === 1) {
             return { id: String(exact[0].id), name: String(exact[0].workflowname ?? ''), source: 'exactName' };
         }
+        // 澄清候选：能对上的那几条优先（比全量 picked 精确），一条都对不上才退回全量。
         const list = exact.length ? exact : picked;
+        // ★ 2026-10-20 用户裁定：澄清前先按「用户近一年实际发起过哪些」消歧。
+        // 用户只发起过其中某一个 ⇒ 直接用，不再问一遍（`from:mineRecentUnique` 标明这是推断的，
+        // 不是用户明说的）。查不到 / 不唯一 / 请求失败 ⇒ 一律回落下面原样的多候选澄清。
+        const inferred = await pickUniqueMineWorkflow(list.map((item) => ({ id: String(item.id), name: String(item.workflowname ?? '') })), env);
+        if (inferred) {
+            return { id: inferred.id, name: inferred.name, source: 'single', from: 'mineRecentUnique' };
+        }
         // `clarificationQuestion` 是**用户口径**：它会被 `note` 要求「原样交给用户确认」，因此
         // 只能写"发生了什么 + 要用户做什么"。**禁止**把本机判定依据（如"其中没有与所写名称完全
         // 一致的"）写进这句——那属于 CLI 内部实现，外传会让用户在确认卡片上看到与己无关的判据
@@ -1496,9 +1606,9 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
  *
  * 背景（2026-09-23 实测 + 用户裁定）：`POST …memoryPrompt` 带 `workflowId` 时返回的是**全集** ——
  * `--- user.md ---` / `--- memory.md ---`（全局画像 + 全局别名映射）+ `--- memory_<workflowId>.md ---`
- * （该工作流维度）。于是 `launchPreferences` 与入口处读过的无参 `workflow.memoryPrompt`（纯全局）
+ * （该工作流维度）。于是这条命令取回的记忆与入口处读过的无参 `workflow.memoryPrompt`（纯全局）
  * **内容重叠**：真机实测同一租户 `promptText` 2,467 字符 = 全局 543 + 工作流维度 1,924，
- * 同一段全局记忆会在上下文里出现两次。而 `launchPreferences` 的语义是「**该工作流的**发起偏好」，
+ * 同一段全局记忆会在上下文里出现两次。而这里要的是「**该工作流的**发起偏好」，
  * 全局那份已由入口读取覆盖，不应重复下发。
  *
  * 故只保留标记 `--- memory_<workflowId>.md ---` 及其**之后**的内容：
@@ -1521,16 +1631,17 @@ function extractWorkflowMemorySection(promptText, workflowId) {
     return text.slice(at).trim();
 }
 /**
- * 顺带取回用户在这条工作流上的发起偏好（`buildAgentMemoryPrompt`，带 `workflowId`）。
+ * 取回用户在这条工作流上的记忆（`buildAgentMemoryPrompt`，带 `workflowId`）。
  *
- * `promptText` **只含该工作流维度的记忆**（全局画像/全局别名由入口的无参 `workflow.memoryPrompt`
- * 覆盖，这里经 `extractWorkflowMemorySection` 裁掉，避免同一段全局记忆在上下文里出现两次）。
+ * 返回值**只含该工作流维度的那一段**（全局画像 / 全局别名由入口的无参
+ * `workflow.memoryPrompt` 覆盖，这里经 `extractWorkflowMemorySection` 裁掉，
+ * 避免同一段全局记忆在上下文里出现两次）。
  *
- * best-effort：读记忆失败（未开通记忆 / 接口不可用）不是错误——一律按新用户处理，
- * 只体现在 `launchPreferences.available` 上，绝不阻断表单载入（与 `workflow.memoryPrompt` 同口径）。
+ * best-effort：读不到（没开通记忆 / 404 / 接口故障）一律返回空串 —— 对模型而言
+ * 「没有记忆」和「读取失败」的处理完全一样（按新用户处理、不要重试），不需要再分档。
+ * 绝不阻断表单载入（与 `workflow.memoryPrompt` 同口径）。
  */
-async function fetchLaunchPreferences(workflowId, env) {
-    const result = { available: false, workflowId, promptText: '' };
+async function fetchWorkflowMemory(workflowId, env) {
     try {
         const response = await env.host.workflowRequest({
             method: 'POST',
@@ -1540,38 +1651,21 @@ async function fetchLaunchPreferences(workflowId, env) {
         });
         // 该接口原始返回是 {code,msg,status,data:"<markdown>",fail}，业务成功标志是 status/fail
         // **不是 success**——这里**不能**用 responseData 解包（会把 data 里的 markdown 当主体，
-        // 导致 promptText 恒空）。与 workflow.memoryPrompt 同源。
-        // 只认 `data`（字符串）作为偏好正文：**不回退 `msg`**——`msg` 里是「接口返回成功」这类
-        // 通用提示，回退它会让"没配记忆"的环境被读成有一条内容是"接口返回成功"的偏好。
+        // 导致正文恒空）。与 workflow.memoryPrompt 同源。
+        // 只认 `data`（字符串）作为正文：**不回退 `msg`**——`msg` 里是「接口返回成功」这类
+        // 通用提示，回退它会让"没配记忆"的环境被读成有一条内容是"接口返回成功"的记忆。
         const body = (response && typeof response === 'object' ? response : {});
-        const rawPromptText = typeof body.data === 'string' ? body.data.trim() : '';
-        const promptText = extractWorkflowMemorySection(rawPromptText, workflowId);
         const businessOk = body.fail !== true && body.status !== false && body.success !== false;
-        result.available = Boolean(businessOk && promptText);
-        result.promptText = promptText;
+        if (!businessOk)
+            return '';
+        const rawPromptText = typeof body.data === 'string' ? body.data.trim() : '';
+        return extractWorkflowMemorySection(rawPromptText, workflowId);
     }
-    catch (error) {
-        // 404 ＝ 该智能体/工作流还没有记忆条目（未开通记忆），属**正常的新用户状态**，不是失败：
-        // 保持 `available:false` + `promptText:''`，**不加任何"失败"提示**、也不阻断任务。
-        // 其它错误才提示"读取失败、按新用户处理"。
-        if (!isNotFoundError(error)) {
-            result.note = '该工作流的记忆偏好读取失败，按新用户处理，不要重试。';
-        }
+    catch {
+        // 404 ＝ 该工作流还没有记忆条目（未开通记忆）、其它错误 ＝ 接口不可用；
+        // 两者都按「没有记忆」处理，既不加提示也不阻断任务。
+        return '';
     }
-    return result;
-}
-/**
- * 是否是「资源不存在」类错误（HTTP 404）。
- *
- * 真机上该错误由 host 统一抛成 `workflowApiError('http_error', 'OA 接口 HTTP 404', {code:404, details:{status:404}})`，
- * 故同时认 `code` 与 `details.status` 两处。不依赖类实例判断，避免把跨包包装过的错误漏掉。
- */
-function isNotFoundError(error) {
-    const record = (error && typeof error === 'object') ? error : {};
-    if (Number(record.code) === 404)
-        return true;
-    const details = record.details;
-    return Boolean(details && typeof details === 'object' && Number(details.status) === 404);
 }
 // ---------------------------------------------------------------------------
 // createForm：解析工作流 + loadBase/loadFrame/loadMinor/formLayout + 字段输出
@@ -1643,23 +1737,105 @@ function singleExplicitWorkflowId(rawWorkflow) {
     const parsed = parseNameWithId(terms[0]);
     return parsed.id ?? (/^[0-9]+$/.test(terms[0]) ? terms[0] : '');
 }
-/** 表单载入 + 该工作流的发起偏好：两者只共享 `workflowId`，可以并行。 */
+/** 表单载入 + 该工作流的记忆：两者只共享 `workflowId`，可以并行。 */
 async function loadCreateFormPack(workflowId, env) {
-    const [{ data }, launchPreferences] = await Promise.all([
+    const [{ data }, workflowMemory] = await Promise.all([
         buildCreateFormData(workflowId, env),
         // 记忆读取是 best-effort（内部全 catch），不会把表单载入的错误顶掉。
-        fetchLaunchPreferences(workflowId, env),
+        fetchWorkflowMemory(workflowId, env),
     ]);
-    return { data, launchPreferences };
+    return { data, workflowMemory };
 }
-async function commandCreateForm(args, env) {
-    // ★ 2026-10-16 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
-    // 起点取在函数入口（含下面那次会话惰性初始化），终点取在结果产出之后 —— 即"从命令开始执行到
-    // 执行完成"。取值不做开关、不进 skill 文档（用户明确要求"直接默认加上"）。
-    const startedAt = Date.now();
+/**
+ * 智能填参：把「用户意图 + 表单字段上下文」交给独立智能体（`chatScene`），换回可直接使用的 `data`。
+ *
+ * ★ **2026-10-23 起本函数没有调用方**（用户裁定：`createForm` 不再接 `userQuestion`、内部不再调
+ * `chatScene`，发起流程改回「`createForm` 取数 → 模型自己拼 `data` → `createRequest`」）。
+ * 连同 `chatscene.ts` 的 `requestFormFill` 一起**保留不删**，只是暂时不接回链路；要恢复时把
+ * `prepareCreateFormPayload` 里那句调用加回来即可。
+ *
+ * ## 什么时候调（恢复时生效）
+ *
+ * 两个条件**同时**成立才调，缺一就原样返回（= 老行为）：
+ * 1. 调用方给了 `userQuestion`（非空）—— 空串时智能体没有可依据的意图，接口也回不出有效结果，
+ *    所以仍以它为前置（2026-10-20 用户裁定）；
+ * 2. 拿到了 `baseUrl`（真连上了 OA）。
+ *
+ * **不看小e 档**（2026-10-20 用户裁定）：以前这一档被跳过，理由是"填单发生在宿主页面、算了也没人用"；
+ * 现在照走 —— 走通时 `createForm` 直接把算好的 `data` 交给模型，页面填单同样能用上。
+ *
+ * ## 失败怎么处理
+ *
+ * `requestFormFill` 内部吞掉所有异常并返回 `ok:false`，这里**直接不当回事**：返回
+ * `applied:false`，调用方照旧回 `historyRequestData` / `systemFields`。智能体挂掉不能把
+ * 发起流程打死 —— 这是本功能唯一的硬约束。
+ *
+ * ## 传什么记忆
+ *
+ * `userMemory` 用该工作流的记忆（`workflowMemory`）。它是
+ * **一段 Markdown 文本**，不是键值对象（2026-10-19 用户裁定）。全局画像由入口处的
+ * `workflow.memoryPrompt` 覆盖，这里不重复取。
+ */
+async function resolveIntentFill(pack, userQuestion, baseUrl, env) {
+    const question = String(userQuestion ?? '').trim();
+    // ★ 2026-10-20 用户裁定（口径修正）：前置**只有两条** ——「`userQuestion` 非空」+「连上了 OA」。
+    // `userQuestion` 为空时智能体没有可依据的意图、接口也回不出有效结果，故照旧不调；
+    // **小e 档不再豁免**（此前 `hasXiaoEEnv` 直接关掉这条链路，现已按用户要求去掉）。
+    // 走通与否仍由接口结果决定：回不出可用的 `data.chatMessage.content`（JSON）就 `applied:false`。
+    if (!question || !baseUrl)
+        return { applied: false };
+    const fields = Array.isArray(pack.data.fields) ? pack.data.fields : [];
+    if (!fields.length)
+        return { applied: false };
+    const input = buildChatSceneInput({
+        userQuestion: question,
+        workflow: {
+            id: String(pack.data.workflow?.id ?? ''),
+            name: String(pack.data.workflow?.name ?? ''),
+        },
+        fields,
+        historyRequestData: pack.data.historyRequestData ?? null,
+        userMemory: String(pack.workflowMemory ?? ''),
+        now: formatLocalNow(),
+    });
+    const outcome = await requestFormFill(env, input);
+    if (!outcome.ok || !outcome.data)
+        return { applied: false };
+    return {
+        applied: true,
+        data: outcome.data,
+        // 智能体的标题规则：有默认值时它只会给空串（沿用默认）；给了值才是用户明确要求的标题
+        requestName: String(outcome.systemData?.requestName ?? '').trim(),
+        // 供 `createRequestDirect` 把「紧急程度 / 密级 / 签字意见」一并透传给 `createRequest`；
+        // `createForm` 自己不消费这几个键（返回面一个字不变）。
+        systemData: outcome.systemData ?? {},
+        // ★ 2026-10-19 用户裁定：把「生成表单参数」这段的耗时单独带出去（只在真走通 chatScene 时才有）。
+        // 口径 = `requestFormFill` 内部这一趟（发请求 → 拿回 content → parse → 归一化），
+        // 不含本函数上游的会话初始化与表单取数 —— 那些已由 `durationMs` 计入，两者是「整条命令」与
+        // 「其中智能体这一段」的关系，不是并列的两笔开销。
+        durationMs: outcome.durationMs,
+    };
+}
+/**
+ * `createForm` 的**取数阶段**（原 `commandCreateForm` 前半段，逐行搬过来，行为一字不改）。
+ *
+ * 抽出来的唯一目的：`createRequestDirect` 需要「未经压缩、未经落盘」的原始 payload ——
+ * `commandCreateForm` 的输出可能因为超线只剩一句"结果已落盘"的提示，取不到键。
+ *
+ * 2026-10-23 用户裁定：本函数**不再**调 `chatScene`（`createForm` 不再接 `userQuestion`）。
+ * 现在返回的就是纯取数结果：`fields` + `historyRequestData` + `systemFields` + 记忆，
+ * 由模型自己拼 `data` 后交给 `createRequest`。
+ */
+async function prepareCreateFormPayload(args, env) {
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
     // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
+    //
+    // 顺带计时：登录取凭据（小e 环境下是 `tokens.py` 换 eteamId + `teamsCheck` 换登录人这一整套）
+    // 走的是 auth 层自己的 fetch，不经 `host.workflowRequest` ⇒ 天然落在 `apiDurations` 之外。
+    // 这一段的耗时单独带出去（`authMs`），否则「总耗时 − 各接口」会凭空多出几百毫秒对不上账。
+    const authStartedAt = Date.now();
     await env.host.getSession();
+    const authMs = Date.now() - authStartedAt;
     let target;
     let pack;
     const explicitId = singleExplicitWorkflowId(args.workflow);
@@ -1691,22 +1867,70 @@ async function commandCreateForm(args, env) {
     // 完整**（pretty JSON，未紧凑），所以模型按提示读回来拿到的是与 stdout 同口径的全量内容。
     //
     // 显式标注为 `Record<string, any>`：`pack.data` 是带索引签名的宽松对象，而对象字面量里又显式写了
-    // `workflow` / `launchPreferences`，TS 的推断会**丢掉索引签名**、只留这两个显式键。
+    // `workflow`，TS 的推断会**丢掉索引签名**、只留这个显式键。
     const fullPayload = {
         ...pack.data,
-        workflow: { ...(pack.data.workflow || {}), selectionSource: target.source },
-        launchPreferences: pack.launchPreferences,
+        workflow: {
+            ...(pack.data.workflow || {}),
+            selectionSource: target.source,
+            // ★ 2026-10-20 用户裁定：`from` **只在**「多候选按近一年发起记录推断出来」这一种场景出现，
+            // 其余场景一个字都不多（模型据此知道这个工作流是推断的，而不是用户明说的）。
+            ...(target.from ? { from: target.from } : {}),
+        },
     };
-    const compacted = await compactFormOutput(fullPayload, env, 'last_create_form.json', [], {
+    // 该工作流的记忆：**一段 Markdown 原文**，读不到就不出这个键（模型见到"没有这个键"就按新用户处理）。
+    if (pack.workflowMemory)
+        fullPayload.workflowMemory = pack.workflowMemory;
+    // ★ 2026-10-23 用户裁定：`createForm` **不再调 `chatScene`**（入参里的 `userQuestion` 也一并取消）。
+    //
+    // 起因：智能填参（2026-10-19 引入）让 `createForm` 在返回前把意图算成 `data`，成功时还会删掉
+    // `historyRequestData` / `systemFields` —— 而现在的流程是「`createForm` 只负责取数（字段 + 历史 +
+    // 系统字段 + 记忆）→ 模型自己拼 `data` → 调 `createRequest`」。中间再跑一次模型既多一笔开销，
+    // 又会让返回面在两套结构之间切换。
+    //
+    // `resolveIntentFill` / `chatscene.ts` 的 `requestFormFill` **保留不删**（万一要恢复这条路），
+    // 只是这里不再调用 —— 因此 `fillDurationMs`（智能体那一段的耗时）也不会再出现。
+    return { payload: fullPayload, authMs };
+}
+async function commandCreateForm(args, env) {
+    // ★ 2026-10-16 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
+    // 起点取在函数入口（含下面那次会话惰性初始化），终点取在结果产出之后 —— 即"从命令开始执行到
+    // 执行完成"。取值不做开关、不进 skill 文档（用户明确要求"直接默认加上"）。
+    const startedAt = Date.now();
+    // ★ 2026-10-21 用户裁定：耗时口径与 `createRequestDirect` **完全一致** —— 除总耗时外再给
+    // 「每个接口多久」（`apiDurations`）与「登录取凭据多久」（`authMs`）。所以这里也把 host 包一层
+    // 逐接口计时，整条命令的请求都会被记上。
+    const spans = [];
+    const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    const { payload: fullPayload, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    // 取数阶段已全部结束 ⇒ 这里拿到的是完整的一份；它既是判线要预留的键，也是最终返回的值。
+    const { durations: apiDurations, slowest: apiSlowest } = summarizeApiSpans(spans);
+    // 判线的位数预留：`durationMs` / `apiDurations` / `apiSlowest` / `authMs` 一定会有。
+    // `apiDurations` 此刻已经求出，直接按真值占（不必用哨兵估）。
+    const reserve = {
+        durationMs: DURATION_RESERVE_SENTINEL,
+        apiDurations,
+        apiSlowest,
+        authMs: DURATION_RESERVE_SENTINEL,
+    };
+    const compacted = await compactFormOutput(fullPayload, timedEnv, 'last_create_form.json', [], {
         safeChars: CREATE_FORM_STDOUT_SAFE_CHARS,
         operation: 'workflow.createForm',
-        // 判线要量"最终打出去的那份文本"，而 `durationMs` 的真值只能在压缩**之后**求（它统计的正是
-        // 整条命令），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘（安全方向）。
-        reserve: { durationMs: DURATION_RESERVE_SENTINEL },
+        // 判线要量"最终打出去的那份文本"，而 `durationMs` 的真值只能在压缩**之后**求
+        // （它统计的正是这段时间），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘
+        // （安全方向）。
+        reserve,
     });
     // 耗时并在 `data` 里（与 `outputChars` / `persistedResult` 这些运行期属性同处）；**两条分支都带上**
     // —— 超线落盘那一档 `data` 只剩一句提示，并进去它才不会恰好在"大表单"时消失。
-    return workflowSuccess('workflow.createForm', { ...compacted, durationMs: Date.now() - startedAt });
+    const result = {
+        ...compacted,
+        durationMs: Date.now() - startedAt,
+        apiDurations,
+        apiSlowest,
+        authMs,
+    };
+    return workflowSuccess('workflow.createForm', result);
 }
 // ---------------------------------------------------------------------------
 // createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
@@ -1735,26 +1959,36 @@ async function buildCreateFormData(workflowId, env) {
     // 结果对象再判定 —— 不能让它们的失败经由 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: [] })
+    //
+    // 2026-10-22（用户裁定；非小e 行为不变）：
+    // ① 小e 环境**不发** `loadMinorInfo`：这一档不做系统字段（流程标题/紧急程度/密级）的必填校验，
+    //    它的 `permissions` / 选项清单用不上，省掉真机 429 ms 的一趟。`tenant/setting` 仍照发
+    //    （`fileUploadParams` 的 sizeLimit 从它来）。
+    // ② `getFormLayout` **挂到 base+frame 之后立刻发**，与 minor/tenant 并行：它只用 runtime 与
+    //    frame（见 `buildLayoutRequest`），原先要等四个都回来才发，白等最慢的那一个。
+    const isXiaoE = hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
+    // `tolerateBusinessError`：loadBase 用 `status:false` + `commonParam.authInfo` 表达
+    // 「不存在 / 无发起权限」，走带业务过滤的通道只会拿到"接口返回状态异常，code=200"。
+    const basePromise = requestJson(env, 'POST', FORM_ENDPOINTS.loadBase, query, body, { tolerateBusinessError: true })
+        .then((value) => ({ ok: true, value }))
+        .catch((error) => ({ ok: false, error }));
+    const framePromise = requestJson(env, 'POST', FORM_ENDPOINTS.loadFrame, query, body)
+        .then((value) => ({ ok: true, value }))
+        .catch((error) => ({ ok: false, error }));
+    // 小e：不发请求，直接给一个"没有 minorInfo"的结果，下游静默降级（不产生告警文本）。
+    const minorPromise = isXiaoE
+        ? Promise.resolve({ ok: false, value: null })
+        : requestJson(env, 'POST', FORM_ENDPOINTS.loadMinor, query, { workflowId, isCreate: 1, isMobile: 0 })
             .then((value) => ({ ok: true, value }))
-            .catch(() => ({ ok: false, value: null })),
-    ]);
+            .catch(() => ({ ok: false, value: null }));
+    const tenantPromise = requestJson(env, 'POST', FORM_ENDPOINTS.tenantSetting, undefined, { setType: [] })
+        .then((value) => ({ ok: true, value }))
+        .catch(() => ({ ok: false, value: null }));
     // 「为什么进不去这张表单」必须**先于**其它接口的错误判定：
     // ID 不存在 / 无发起权限时，真机上 `loadFrameParam`、`loadMinorInfo` 会返回
     // `code:500「无流程查看权限」`——那是**后果**不是**原因**。若让它先外溢，模型只能对着
     // "无流程查看权限"猜，说不出到底是「ID 不存在」还是「存在但没权限」。
+    const [baseOutcome, frameOutcome] = await Promise.all([basePromise, framePromise]);
     if (baseOutcome.ok) {
         const blocked = readCreateFormBlock(baseOutcome.value);
         if (blocked)
@@ -1764,10 +1998,25 @@ async function buildCreateFormData(workflowId, env) {
         throw baseOutcome.error;
     if (!frameOutcome.ok)
         throw frameOutcome.error;
+    const base = baseOutcome.value;
+    const frameData = frameOutcome.value;
+    const runtime = parseRuntime(base, workflowId);
+    const frame = parseFrame(frameData, runtime.node_id);
+    // 表单布局只依赖上面这两个结果 —— 拿到就发，不陪 minor/tenant 一起等。
+    const layoutPromise = requestJson(env, 'POST', formApiUrl(FORM_ENDPOINTS.formLayout, frame.relate_type), { formId: frame.form_id, ...AJAX_QUERY }, buildLayoutRequest(workflowId, runtime, frame))
+        .then((value) => ({ ok: true, value }))
+        .catch((error) => ({ ok: false, error }));
+    const [layoutOutcome, minorOutcome, tenantOutcome] = await Promise.all([layoutPromise, minorPromise, tenantPromise]);
+    if (!layoutOutcome.ok)
+        throw layoutOutcome.error;
     const minorWarningText = 'loadMinorInfo 获取系统字段权限失败，跳过系统字段（流程标题/紧急程度/密级）必填校验';
     let minorInfo = {};
     let minorWarning = null;
-    if (minorOutcome.ok) {
+    if (isXiaoE) {
+        // 小e：本来就没发这个请求 ⇒ 按"没有系统字段权限"静默降级，不把告警塞给模型。
+        minorWarning = null;
+    }
+    else if (minorOutcome.ok) {
         try {
             minorInfo = parseMinorInfo(minorOutcome.value);
         }
@@ -1779,10 +2028,6 @@ async function buildCreateFormData(workflowId, env) {
     else {
         minorWarning = minorWarningText;
     }
-    const base = baseOutcome.value;
-    const frameData = frameOutcome.value;
-    const runtime = parseRuntime(base, workflowId);
-    const frame = parseFrame(frameData, runtime.node_id);
     // tenantSetting 取不到时按 {} 处理（与串行版的 catch 分支同口径）。
     let tenantSetting = {};
     if (tenantOutcome.ok) {
@@ -1793,7 +2038,7 @@ async function buildCreateFormData(workflowId, env) {
             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 layoutResp = layoutOutcome.value;
     const layoutData = layoutResp;
     if (!layoutData || typeof layoutData !== 'object')
         throw workflowApiError('format_error', 'getFormLayout 未返回有效 data');
@@ -1856,7 +2101,7 @@ async function buildCreateFormData(workflowId, env) {
      * 小e 环境下两处都不跑（`createRequest` 同档也跳过字段联动与显示属性联动，由浏览器页面自己算）。
      * 非小e 环境行为不变。
      */
-    if (!hasXiaoEEnv(env.ctx.env) && linkageActions.length) {
+    if (!isXiaoE && linkageActions.length) {
         const loadEntries = _entriesFromDefaults(defaults);
         try {
             onLoadLinkage = await runFieldLinkage(env, buildLinkageContext({ runtime, frame, layout: { form_id: frame.form_id }, linkageActions }), loadEntries, new Set(['onLoadForm']), defaults);
@@ -2201,12 +2446,18 @@ function bindInputFields(main, details, fields) {
         if (field)
             entries.push({ field, value: main[key] });
     }
-    const rowSeed = Date.now() * 100000 + Math.floor(Math.random() * 70000) + 10000;
+    // ★ 2026-10-26 修复：`rowId` 必须**每行唯一**，服务端就是按 `(subForm.id, rowId)` 分行的
+    // （同一行所有字段共用一个 rowId，不同行 rowId 不同）。原来用
+    // `Date.now() * 100000 + ...` 得到 ≈1.79e17，已越过 `Number.MAX_SAFE_INTEGER`（9.0e15），
+    // double 在该量级的精度间距是 32 ⇒ `+1/+2/+3` 全被舍回同一个数，4 行明细塌成 1 行。
+    // 改用 BigInt 生成，保持同一套 18 位数值形态但不再丢精度。
+    const rowSeed = BigInt(Date.now()) * 100000n
+        + BigInt(Math.floor(Math.random() * 70000) + 10000);
     let rowOffset = 0;
     for (const subFormId of Object.keys(details)) {
         const rows = details[subFormId];
         rows.forEach((row, index) => {
-            const rowId = String(rowSeed + rowOffset);
+            const rowId = String(rowSeed + BigInt(rowOffset));
             rowOffset += 1;
             const rowMeta = { dataIndex: index + 1, rowId, subForm: { id: subFormId } };
             for (const key of Object.keys(row)) {
@@ -2372,6 +2623,23 @@ function splitValueAliases(raw) {
     }
     return out;
 }
+/**
+ * 一个格子要送去查候选的「说法」清单——**按字段是单选还是多选分叉**：
+ *
+ *   - **单选**：整串与各说法一并登记，由 `resolveBrowserAliases` 的「整串优先」先试整串
+ *     （名称本身自带逗号时不会被拆错）；
+ *   - **多选**：逗号是**值分隔符**，只拆不拼——整串既不做「整串优先」，也**不进候选池**。
+ *     否则「张三,李四」会被整串当成一个名称，恰好命中就静默吞成一个值（真机问题：
+ *     多选浏览字段只写进去第一个对象），而且还会白花一次 complete / nameToId 往返。
+ *
+ * 多选里若单个对象名真的自带逗号，由 `名称(ID)` 显式指定（`resolveBrowserAliases` 认它）。
+ */
+function lookupTermsOf(field, raw) {
+    const aliases = splitValueAliases(raw);
+    if (field && field.isMultiple)
+        return aliases.length ? aliases : [raw];
+    return aliases.length > 1 ? [raw, ...aliases] : [raw];
+}
 /** 浏览按钮字段解析不出来的统一出口。`candidates` **只含关键词真实命中**，绝不用首页枚举冒充。 */
 function browserAmbiguity(field, input, hits) {
     return new ValueAmbiguity({
@@ -2421,8 +2689,11 @@ function resolveBrowserAliases(field, raw, lookup) {
         return out;
     };
     const aliases = splitValueAliases(raw);
-    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定
-    const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定。
+    // 多选字段只登记切段结果（见 lookupTermsOf）。
+    const terms = lookupTermsOf(field, raw);
+    /** 「整串优先」只对**单选**成立：多选里逗号是值分隔符，整串本身不是候选名称。 */
+    const wholeTermFirst = !(field && field.isMultiple) && aliases.length > 1;
     const pool = [];
     /** 每个词各自「字面同名」的候选（显式 ID 也算字面命中，它本来就是精确值）。 */
     const literalByTerm = new Map();
@@ -2435,8 +2706,8 @@ function resolveBrowserAliases(field, raw, lookup) {
         literalByTerm.set(term, candidates.filter((c) => String(c?.name ?? '') === term));
     }
     const poolHits = dedupe(pool);
-    // ① **整串优先**：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
-    if (aliases.length > 1) {
+    // ① **整串优先**（仅单选）：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
+    if (wholeTermFirst) {
         const wholeHits = dedupe(literalByTerm.get(raw) || []);
         if (wholeHits.length === 1)
             return wholeHits[0];
@@ -2582,6 +2853,7 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
             if (!item || typeof item !== 'object') {
                 throw new ValueAmbiguity({ kind: 'EMPLOYEE_SCOPE', fieldId: field.id, fieldName: field.name, reason: '人员范围字段的值必须是对象数组，每项含 name 和 type', resolution: '格式如 [{"name":"袁湘云","type":"user"}]' });
             }
+            // 入参键名：`id`/`name` 是现行口径（智能体侧），`optionId`/`content` 是历史写法，两套都收。
             const optionId = String(item.optionId ?? item.id ?? '').trim();
             const content = String(item.content ?? item.name ?? '').trim();
             const scopeType = String(item.type ?? '').trim();
@@ -2593,7 +2865,7 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 continue;
             }
             if (!content || !scopeType) {
-                throw new ValueAmbiguity({ kind: 'EMPLOYEE_SCOPE', fieldId: field.id, fieldName: field.name, input: item, reason: '缺少名称或类型', resolution: '每项必须含 name/content 与 type（user/dept/subcompany/group/role/position/external/all/allExternal）' });
+                throw new ValueAmbiguity({ kind: 'EMPLOYEE_SCOPE', fieldId: field.id, fieldName: field.name, input: item, reason: '缺少名称或类型', resolution: '每项必须含 name 与 type（user/dept/subcompany/group/role/position/external/all/allExternal）' });
             }
             // 名称/类型齐了却没拿到 ID：说明名称→ID 解析没成功（预解析失败或未走预解析）。
             // **绝不静默丢弃**——空 optionId 会让 hasDetailValue 判为无值，整条值从保存体里消失，
@@ -2679,6 +2951,18 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 const key = `${field.id}_${rowIndex}_${term}`;
                 return { mapped: mappings[key] || [], completed: browserHints[key] || [] };
             };
+            if (field.isMultiple) {
+                // 多选：一个格子里的逗号是**值分隔符**，逐说法各解析出一条 `dataOptions`
+                // （整串不当名称，见 lookupTermsOf）。某个说法有歧义时整条值都不落地，
+                // 由该说法自己的候选澄清——已解析出的兄弟值**不丢**，因为澄清后会整条重发。
+                for (const term of lookupTermsOf(field, raw)) {
+                    const pickedOne = resolveBrowserAliases(field, term, lookup);
+                    if (options.some((o) => o.optionId === pickedOne.id))
+                        continue;
+                    options.push({ optionId: pickedOne.id, content: pickedOne.name });
+                }
+                continue;
+            }
             const picked = resolveBrowserAliases(field, raw, lookup);
             options.push({ optionId: picked.id, content: picked.name });
         }
@@ -2751,6 +3035,9 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
  * `{"optionId":"<解析出的ID>","content":"刘艳","type":"user","optionObj":<接口原始对象>}`，
  * 交给 `serializeValue` 的"已解析"分支直接透传。解析不到（0 命中/多命中）时把歧义挂到该条目上，
  * 由主循环原样报给模型（带候选），**不允许退化成一个空 optionId 被静默丢掉**。
+ *
+ * ★ 2026-10-22 用户裁定：智能体入参统一成 `{"type":…,"id":…,"name":…}`（不再用 `optionId`/`content`）。
+ * 入参侧三个键名都收（`id`/`optionId`、`name`/`content`），内部与服务端仍用 `optionId`/`content`。
  */
 async function preResolveEmployeeScopeEntries(env, entries) {
     const failures = new Map();
@@ -2788,7 +3075,7 @@ async function preResolveEmployeeScopeEntries(env, entries) {
                     reason: selected.length ? 'MULTIPLE_MATCHES' : 'NOT_FOUND',
                     candidates: selected.map((c) => ({ id: c.id, name: c.name })),
                     resolution: selected.length
-                        ? `把 candidates 原样交给用户确认；用户选定后由你取该项的 id / name 拼出 {"optionId":…,"content":…,"type":"${scopeType}"} 重发同一条命令（不要让用户提供 ID）。`
+                        ? `把 candidates 原样交给用户确认；用户选定后由你取该项的 id / name 拼出 {"id":…,"name":…,"type":"${scopeType}"} 重发同一条命令（不要让用户提供 ID）。`
                         : '该名称在系统里没有匹配。请让用户给出该对象的完整名称，或其它可用于检索的关键词（不要向用户索取 ID）。',
                 };
                 break;
@@ -2897,8 +3184,8 @@ async function resolveEntryValues(env, entries, formId) {
                 continue;
             // 一个格子可写多个「说法」（逗号分隔）：**整串与各说法一起登记**——这样"整串优先"要用的
             // 整串候选、以及各说法各自的候选，都在同一批里拿到（nameToId 一把批量发，未命中的再并行补）。
-            const aliases = splitValueAliases(raw);
-            const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+            // 多选字段只登记切段结果（逗号是值分隔符，见 lookupTermsOf）。
+            const terms = lookupTermsOf(field, raw);
             // 候选来源二选一：控件自带 `browserModule`+`browserType` ⇒ 只走 complete（下一步补查），
             // **不进 nameToId 批次**；否则只走 nameToId。这样池子里永远只有一个来源，不会互相污染。
             const hasBrowserChannel = Boolean(field.browserModule && field.browserType);
@@ -3191,6 +3478,147 @@ function _detailValueIds(detail) {
     }
     return ids;
 }
+/**
+ * 把一个值拆成「可比 token」集合：`id` / `optionId` / `name` / `content`，以及去掉尾部
+ * `(id)` / `（id）` 后缀的纯文本。
+ *
+ * 为什么要拆：入参是**原始串**（`"银行（个人报销）(7)"`、`"20260999"`），基线是 **detail**
+ * （`dataOptions:[{optionId:'7',content:'银行（个人报销）'}]`、`{content:'20260999'}`），
+ * 直接比 `_entryValueIds` 与 `_detailValueIds` 会得到 `["银行（个人报销）(7)"]` vs
+ * `["银行（个人报销）","7"]` 这种必不相等的形状。取交集判等才不会误判成"变了"。
+ */
+function _pushComparableToken(tokens, raw) {
+    const text = String(raw ?? '').trim();
+    if (!text)
+        return;
+    tokens.add(text);
+    const matched = text.match(/^(.*?)\s*[（(]\s*([^（）()]*?)\s*[)）]$/);
+    if (matched) {
+        // 尾部括号里是 id 时（`银行（个人报销）(7)`、`泛微上海(100504500000311504)`）也要能对上
+        if (matched[1].trim())
+            tokens.add(matched[1].trim());
+        if (matched[2].trim())
+            tokens.add(matched[2].trim());
+    }
+}
+function _entryComparableTokens(source) {
+    const tokens = new Set();
+    for (const item of listValues(source)) {
+        if (item && typeof item === 'object') {
+            for (const key of ['id', 'optionId', 'value', 'name', 'content']) {
+                if (item[key] !== undefined && item[key] !== null)
+                    _pushComparableToken(tokens, item[key]);
+            }
+        }
+        else {
+            _pushComparableToken(tokens, item);
+        }
+    }
+    return tokens;
+}
+/** 基线 detail 的可比 token（与 `_entryComparableTokens` 同一套口径）。 */
+function _baselineComparableTokens(detail) {
+    const tokens = new Set();
+    if (detail && typeof detail === 'object') {
+        if (detail.content !== undefined && detail.content !== null)
+            _pushComparableToken(tokens, detail.content);
+        if (detail.dataText && typeof detail.dataText === 'object' && detail.dataText.content !== undefined) {
+            _pushComparableToken(tokens, detail.dataText.content);
+        }
+        for (const option of detail.dataOptions || []) {
+            if (!option || typeof option !== 'object')
+                continue;
+            if (option.optionId !== undefined && option.optionId !== null)
+                _pushComparableToken(tokens, option.optionId);
+            if (option.content !== undefined && option.content !== null)
+                _pushComparableToken(tokens, option.content);
+            if (option.name !== undefined && option.name !== null)
+                _pushComparableToken(tokens, option.name);
+        }
+    }
+    return tokens;
+}
+/**
+ * 入参这条值是否**与基线相同**（即"用户没动过"）。
+ *
+ * 判松不判严（任一 token 命中即算相同）：漏判"变了"只会少触发一次联动（页面语义本来就是
+ * 没变不触发）；误判"没变"则会把用户真实修改的字段跳过，风险更大，所以这里宁可宽。
+ * 基线里没有该字段 / 基线没值时一律视为"变了"（首次填写必须触发）。
+ */
+function _sameAsBaseline(entry, detail) {
+    const base = _baselineComparableTokens(detail);
+    if (!base.size)
+        return false;
+    const incoming = _entryComparableTokens(entry.value);
+    if (!incoming.size)
+        return false;
+    for (const token of incoming) {
+        if (base.has(token))
+            return true;
+    }
+    return false;
+}
+/**
+ * 「值真的变了的字段 id」——`changeField` 类联动的触发依据（2026-10-20 用户裁定）。
+ *
+ * 旧口径把**入参里出现的字段**一律当成变更字段（模拟页面 onchange），于是"把表单默认值原样
+ * 回传"会伪造出一次"用户修改"：真机坑是 `合同号=20260999`（= 该字段 `initialValue`）被
+ * `createForm.data` 带出来、又被整份回传给 `createRequest`，触发合同号的 changeField 联动，
+ * 服务端按合同重算 `相关客户` 等 7 个字段把 `相关客户` 置空 ⇒ 必填缺失。
+ *
+ * 现在的口径：**只有值与基线不同才算变更**。
+ * - 发起流程：基线 = 表单默认值（`context.defaults`）
+ * - 编辑流程：基线 = 编辑前的字段值（`context.currentDetails`，来自 edit-load 的 `dataDetails`）
+ *
+ * 明细行按 `(subFormId, dataIndex)` 定位基线；明细默认值常常没有行号，此时回落到"同字段任一基线"
+ * （见 `byField`）——宁可判"没变"，也不要让无行号的默认值把每一行都判成变更。
+ */
+function _changedFieldIds(entries, baseline) {
+    const byRow = new Map();
+    const byField = new Map();
+    const pushTo = (map, key, item) => {
+        const bucket = map.get(key);
+        if (bucket)
+            bucket.push(item);
+        else
+            map.set(key, [item]);
+    };
+    for (const detail of baseline || []) {
+        if (!detail || typeof detail !== 'object')
+            continue;
+        const fieldId = String((detail.formField && detail.formField.id) ?? '').trim();
+        if (!fieldId)
+            continue;
+        const subFormId = String((detail.subForm && detail.subForm.id) ?? '').trim();
+        const hasRow = detail.dataIndex !== undefined && detail.dataIndex !== null;
+        const dataIndex = hasRow ? String(detail.dataIndex) : '';
+        pushTo(byField, fieldId, detail);
+        if (hasRow)
+            pushTo(byRow, `${subFormId}\u0000${fieldId}\u0000${dataIndex}`, detail);
+    }
+    const changed = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!entry.field || typeof entry.field !== 'object')
+            continue;
+        const fieldId = String(entry.field.id ?? '').trim();
+        if (!fieldId || seen.has(fieldId))
+            continue;
+        const row = (entry.row && typeof entry.row === 'object') ? entry.row : null;
+        const subFormId = row ? String((row.subForm && row.subForm.id) ?? '').trim() : String(entry.field.subFormId ?? '').trim();
+        const hasRow = Boolean(row) && row.dataIndex !== undefined && row.dataIndex !== null;
+        const candidates = hasRow
+            ? (byRow.get(`${subFormId}\u0000${fieldId}\u0000${String(row.dataIndex)}`) || [])
+            : (byField.get(fieldId) || []);
+        const fallback = hasRow ? (byField.get(fieldId) || []) : [];
+        const unchanged = [...candidates, ...fallback].some((detail) => _sameAsBaseline(entry, detail));
+        if (unchanged)
+            continue;
+        seen.add(fieldId);
+        changed.push(fieldId);
+    }
+    return changed;
+}
 function _linkageOptions(sourceContent) {
     if (!sourceContent || typeof sourceContent !== 'string' || !sourceContent.trim())
         return [];
@@ -3315,9 +3743,10 @@ function _mainValueMap(details) {
     }
     return result;
 }
-async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false) {
-    const changedIds = entries.filter((e) => e.field && typeof e.field === 'object' && String(e.field.id ?? '').trim())
-        .map((e) => String(e.field.id));
+async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false, baseline) {
+    // 只有「值与基线（发起=表单默认值 / 编辑=编辑前值）不同」的字段才算变更字段，
+    // 见 `_changedFieldIds` 的注释（2026-10-20 用户裁定：值没变就不该触发 changeField 联动）。
+    const changedIds = _changedFieldIds(entries, baseline);
     const runDataList = _buildLinkageRunData(ctx.linkageActions, changedIds, actionTypes);
     const neededIds = _neededLinkageFieldIds(ctx.linkageActions, runDataList);
     const dataList = [];
@@ -4018,7 +4447,8 @@ function mainFilledRows(fields, values, hiddenIds, disabledIds, compsFieldIds) {
  * 表格口径**，只换结论句与末段（那边要说清"还没发起 + 还差哪几项"）；`NEEDS_CONFIRMATION` 不给
  * 文本（要先解决 `ambiguities` 再重发）。
  *
- * 内容分四段：结论（`message`，命令已写好的中文）→ 编号/链接 → 主表「已填内容」两列表
+ * 内容分四段：结论（`message`，命令已写好的中文；**只用来渲染，渲染后这个键不再返回**）→ 编号/链接
+ * → 主表「已填内容」两列表
  * （系统字段如流程标题在前，业务字段按表单布局顺序随后；行由 `mainFilledRows` + `systemFilledRows`
  * 算好传进来，命令侧只有这一处口径）→ 各明细表（Excel 列形态）→ 提交失败原因 / 草稿缺项提醒（有才出现）。
  */
@@ -4262,6 +4692,47 @@ function xiaoEUrlParamValue(value) {
  * 明细字段（`preview` 里带 `dataIndex`）按**行号升序**取值、用 `;` 连接；主表字段就是它自己的值。
  * 值为空（没解析出内容）的字段整个省略，不生成空参数。
  */
+/**
+ * 小e 档交给浏览器页面的字段值：只留**可见且可编辑**的那些（2026-10-21 用户裁定）。
+ *
+ * 依据是 `computeLinkageVisibility` 用句柄里本地 `viewLinkages` 求出来的隐藏 / 禁用，再加上字段
+ * 自身的只读、禁填、初始隐藏（`display === false`）与布局隐藏（`hiddenCellFieldIds`）。
+ *
+ * 过滤的**只有值**，不改页面结构：这些字段在表单页里本来就填不进去（页面自己会拦），把值塞过去
+ * 只会让页面报错或让用户看到"填了但没生效"。
+ */
+function editablePreviewForXiaoE(preview, fields, visibility) {
+    const fieldById = new Map();
+    for (const field of toArray(fields)) {
+        const id = String(field?.id ?? '').trim();
+        if (id)
+            fieldById.set(id, field);
+    }
+    const kept = [];
+    for (const item of toArray(preview)) {
+        const fieldId = String(item?.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        const field = fieldById.get(fieldId) || {};
+        if (field.readOnly || field.disableEdit || field.display === false)
+            continue;
+        if (visibility.hiddenFieldIds.has(fieldId))
+            continue;
+        const subFormId = String(field.subFormId ?? '').trim();
+        if (subFormId && visibility.hiddenSubforms.has(subFormId))
+            continue;
+        // 行键口径与 `computeLinkageVisibility` 完全一致（'main' 或 `<subFormId>:<dataIndex>`，
+        // 明细行没给行号时按第 1 行算）。
+        const hasRow = item?.dataIndex !== undefined && item?.dataIndex !== null;
+        const rowKey = rowKeyFor(subFormId, hasRow ? item.dataIndex : undefined);
+        if (visibility.rowHidden[rowKey]?.has(fieldId))
+            continue;
+        if (visibility.rowDisabled[rowKey]?.has(fieldId))
+            continue;
+        kept.push(item);
+    }
+    return kept;
+}
 function xiaoECustomParams(preview) {
     const ordered = [];
     const mainValues = new Map();
@@ -4336,9 +4807,111 @@ function renderXiaoEFillFormMarkdown(params) {
     };
     return `<browsertool>\n${JSON.stringify(payload, null, 2)}\n</browsertool>`;
 }
-// ---------------------------------------------------------------------------
-// createRequest（合并原 createPrepare + createApply）
-// ---------------------------------------------------------------------------
+/**
+ * 把命令耗时并回 `data` 顶层 —— `createRequest` 与 `createRequestDirect` **共用这一份口径**
+ * （2026-10-21 用户裁定：`createRequest` 也要给耗时，且与 `createRequestDirect` 一致）：
+ * - `durationMs` = 命令入口 → 结果产出；
+ * - `apiDurations` = 每个接口（并行批次合成一个 key，取墙钟、不叠加）；
+ * - `apiSlowest` = 每个**真并行**批里谁最慢（`[{ batch, name, ms, items }]`，`ms` 是该接口自身耗时，
+ *   `items` 是批内每个成员的 `{ name, at, ms }`，按 `ms` 降序）；
+ * - `authMs` = 登录取凭据（首次会话解析）的墙钟 —— 这一段走 auth 层自己的 fetch、不经
+ *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账。
+ *
+ * `data` 不是普通对象时原样返回（被替换成字符串 / 数组的返回面一个字都不动）。
+ */
+function stampCommandTimings(envelope, timing) {
+    const data = envelope?.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return envelope;
+    const mutable = data;
+    const { durations, slowest } = summarizeApiSpans(timing.spans);
+    mutable.durationMs = Date.now() - timing.startedAt;
+    mutable.apiDurations = durations;
+    mutable.apiSlowest = slowest;
+    mutable.authMs = timing.authMs;
+    return envelope;
+}
+/**
+ * 取第一个**非空**字符串。
+ *
+ * 系统字段的兜底链原来是 `a ?? b ?? c`，但 `??` 挡不住空串：`systemFields.defaults.requestName`
+ * 的构造是 `runtime.default_request_name || ''`，一旦 OA 没给默认标题，这条链就停在 `''` 上、
+ * 后面的 `context.workflow.name` / `'新建流程'` 全被短路掉。提示词改成「用户没说就不传 key」之后，
+ * 这条链路会真的走到（以前是智能体拿默认值补的），所以按"跳过空串"取值。
+ */
+function firstNonEmptyString(values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+/**
+ * 系统字段「文本口径」归一（2026-10-22 用户裁定）：提示词里紧急程度 / 密级已改成**文本字段**，
+ * 智能体给的是用户原话（「紧急」「机密」「加急」…），而服务端要的是 `levelOptions[].code` /
+ * `secLevelOptions[].id`。这里做一次「原话 → 编码」的映射：
+ *
+ * 1. 原样命中编码（`code` / `id`）⇒ 用编码；
+ * 2. 命中选项**名称**（忽略空白与大小写）⇒ 换成编码；
+ * 3. 兜底「宽松包含」（用户说「加急」、选项名「紧急加急」）⇒ 换成编码；
+ * 4. 三层都命中不了 ⇒ **原样透传**：不静默丢掉用户说的内容，也不编造编码。
+ *
+ * 选项清单来自 `loadMinorInfo`；取不到（小e 档、老句柄）时清单为空 ⇒ 全部走第 4 条，
+ * 行为与改造前完全一致（改造前就是原样透传）。
+ */
+function normalizeSystemChoice(value, options, codeKey) {
+    const text = String(value ?? '').trim();
+    if (!text)
+        return '';
+    const list = (Array.isArray(options) ? options : []).filter((item) => item && typeof item === 'object');
+    const norm = (raw) => String(raw ?? '').replace(/\s+/gu, '').toLowerCase();
+    const target = norm(text);
+    if (!target)
+        return '';
+    const codeOf = (item) => String(item?.[codeKey] ?? '').trim();
+    for (const item of list) {
+        const code = codeOf(item);
+        if (code && norm(code) === target)
+            return code;
+    }
+    for (const item of list) {
+        const code = codeOf(item);
+        if (code && norm(item?.name) === target)
+            return code;
+    }
+    for (const item of list) {
+        const name = norm(item?.name);
+        const code = codeOf(item);
+        if (name && code && (name.includes(target) || target.includes(name)))
+            return code;
+    }
+    return text;
+}
+/**
+ * `createRequest` 的耗时外壳：建计时通道 + 量登录耗时 + 把三个耗时键并回结果。
+ *
+ * 参数明显不合法（`action` 不对 / 没 `context`）时**不先登录** —— 那两种情况内层会直接抛
+ * 参数错，为一个注定失败的调用白走一趟统一登录不值当；真正的报错措辞仍由内层给出。
+ */
+async function commandCreateRequest(args, env, options = {}) {
+    const startedAt = Date.now();
+    const spans = options.apiSpans ?? [];
+    // `createRequestDirect` 已经把 host 包过一层（它的片段数组覆盖到表单载入那一段）⇒ 这里不能再包，
+    // 否则每个请求会被记两遍（key 里会出现重名）。
+    const timedEnv = options.apiSpans ? env : { ...env, host: withApiTiming(env.host, spans) };
+    const action = String(args.action ?? '').trim();
+    let authMs = 0;
+    if ((action === 'draft' || action === 'submit') && String(args.context ?? '')) {
+        // 会话是惰性的：内层的 `verifyContextLease` 本来也会取一次，这里只是把它**提前并单独计时**，
+        // 拿到的仍是同一份缓存，不额外多发请求。
+        const authStartedAt = Date.now();
+        await timedEnv.host.getSession();
+        authMs = Date.now() - authStartedAt;
+    }
+    const envelope = await runCreateRequest(args, timedEnv, options);
+    return stampCommandTimings(envelope, { startedAt, spans, authMs });
+}
 /**
  * `workflow.createRequest` —— **一条命令**完成「字段解析 → 联动 → 必填校验 → 保存 → 发起」。
  *
@@ -4350,7 +4923,7 @@ function renderXiaoEFillFormMarkdown(params) {
  * 返回**不消费**句柄，于是模型补齐字段后可以带**同一个 context** 重发，不必回头重跑 createForm；
  * 一旦消费，就只能按句柄状态分流（`ALREADY_APPLIED` / 结果不确定 / 并发占用）。
  */
-async function commandCreateRequest(args, env) {
+async function runCreateRequest(args, env, options = {}) {
     const action = String(args.action ?? '').trim();
     if (action !== 'draft' && action !== 'submit') {
         throw workflowValidationError('action_required', 'action 必填，且只能是 draft（仅存草稿）或 submit（提交审批）');
@@ -4395,17 +4968,22 @@ async function commandCreateRequest(args, env) {
      * （`buildCreateFormData`，那边的联动结果要用来算字段的必填 / 可编辑清单）；这里两者都不跑 ——
      * 本档既不做必填判定、也不发写请求。非小e 环境行为不变。
      */
-    const isXiaoE = hasXiaoEEnv(env.ctx.env);
+    const isXiaoE = hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
     const linkageDetails = isXiaoE
         ? []
-        : await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false);
+        : await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false, context.defaults || []);
     // 明细默认值无行号，而判缺失/写载荷都按行号索引 ⇒ 按用户已建行补齐缺口（V12.1.35，
     // 详见 fillDetailDefaultsByRow 注释）。放在联动之后合并，联动带出的值仍然优先。
     const merged2 = fillDetailDefaultsByRow(mergeLinkageDetails(merged, linkageDetails), context.defaults || [], userDetailRows(entries));
     const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
     const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
     const [hiddenSubforms, rowHidden, rowExtraRequired, rowDisabled] = isXiaoE
-        ? emptyLinkageVisibility()
+        ? (options.xiaoEViewLinkageFilter
+            // 2026-10-21 用户裁定（`createRequestDirect` 这一档）：小e 档**照跑显示属性联动**，只是不跑字段联动
+            // —— 它要据此把页面本来就填不进去的字段（隐藏 / 禁用）从要填的值里剔掉。
+            // 第三参传 `[]`（本次没有联动带出的值）时，求值只用表单默认值 + 本次入参 + 系统字段值。
+            ? computeLinkageVisibility(context.viewLinkages, entries, context.defaults || [], [], context.systemFieldValues, fields)
+            : emptyLinkageVisibility())
         : computeLinkageVisibility(context.viewLinkages, entries, context.defaults || [], linkageDetails, context.systemFieldValues, fields);
     const initialHidden = new Set(fields.filter((f) => f.display === false).map((f) => String(f.id ?? '')));
     if (initialHidden.size) {
@@ -4420,8 +4998,13 @@ async function commandCreateRequest(args, env) {
     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();
-    const secLevelArg = String(args.secLevel ?? '').trim();
+    // 选项清单的键名随版本变过一次：`createForm` 句柄里是 snake_case，别处可能给 camelCase，两种都收
+    // （与下方 `systemFilledRows` 同一口径）。
+    const levelOptions = (context.systemFields && (context.systemFields.level_options || context.systemFields.levelOptions)) || [];
+    const secLevelOptions = (context.systemFields && (context.systemFields.sec_level_options || context.systemFields.secLevelOptions)) || [];
+    // 紧急程度 / 密级：提示词里是文本字段 ⇒ 入参可能是用户原话，先归一成编码（取不到选项就原样透传）。
+    const requestLevelArg = normalizeSystemChoice(args.requestLevel, levelOptions, 'code');
+    const secLevelArg = normalizeSystemChoice(args.secLevel, secLevelOptions, 'id');
     const requestNameValue = String(args.requestName ?? sysDefaults.requestName ?? '').trim();
     const requestLevelValue = requestLevelArg || String(sysDefaults.requestLevel ?? '').trim();
     const secLevelValue = secLevelArg || String(sysDefaults.secLevel ?? '').trim();
@@ -4487,8 +5070,8 @@ async function commandCreateRequest(args, env) {
         secLevel: secLevelValue,
         permissions: sysPermissions,
         // 老句柄可能没有这两个选项清单（键名也随版本变过一次），取不到就退化成"不列系统字段"。
-        levelOptions: (context.systemFields && (context.systemFields.level_options || context.systemFields.levelOptions)) || [],
-        secLevelOptions: (context.systemFields && (context.systemFields.sec_level_options || context.systemFields.secLevelOptions)) || [],
+        levelOptions,
+        secLevelOptions,
     });
     if (valueAmbiguities.length) {
         return workflowSuccess('workflow.createRequest', {
@@ -4518,17 +5101,16 @@ async function commandCreateRequest(args, env) {
      * 渲染档（2026-10-15 用户裁定）：`finalMarkdown` **整体就是一段 `<browsertool>` 标签块**；本轮回复正文
      * = 这段内容本身（从 `<browsertool>` 到 `</browsertool>`），原样输出、**不要包在代码块里**。
      *
-     * **stdout 形态**（同日第二次裁定「xiaoe 下应该直接输出 `<browsertool>` 标签」）：这一档的 stdout
-     * **就是那段标签块本身，不套 JSON 信封** —— 判定与落点都在 `shortcuts/workflow/index.ts` 的
-     * `rawStdoutOf()` / `executeAndPrint()`（放在命令层是因为"打到 stdout 的形态"属命令层职责）。
-     * 所以下面的 `message` / `workflow` 等键**不会出现在 stdout 上**，它们只对 `--input-ref` 这类
-     * 程序化消费者有意义；模型侧看到的就是标签块，读法见 `workflow-create.md` 第 3 步与处置表。
+     * **stdout 形态**（2026-10-21 用户裁定，**改口径**）：这一档同样**走 JSON 信封**，标签块放在
+     * `data.finalMarkdown` 里 —— 与 `createRequestDirect` 统一，模型侧只有一条读法；`durationMs` /
+     * `apiDurations` / `apiSlowest` / `authMs` 四个耗时键也因此在这一档可见。原来的「stdout 直接就是标签块、不套
+     * 信封」已作废（`shortcuts/workflow/index.ts` 的直出通道随之删除）。
+     * 所以下面的 `message` 要明确告诉模型：从 `data.finalMarkdown` 取内容、原样作为本轮回复正文。
      *
-     * 判据：`auth/xiaoe.ts` 的 `hasXiaoEEnv(env.ctx.env)`（2026-10-16 用户裁定，统一走公共判据）。
-     * 它已覆盖宿主的两种形态 —— 网页端（`XIAOE_USER_TOKEN` + `XIAOE_DOMAIN` 平台凭证）与桌面客户端
-     * （`XIAOE_DATA_ROOT` / `XIAOE_ROBOT_DATA_ROOT` / `XIAOE_USER_SETTINGS_PATH` / `XIAOE_ROBOT_ROOT`
-     * 四个运行期路径变量），同时仍对 `WORKBUDDY_*` / `CODEX_*` 做排他短路。本处复用上面算好的
-     * `isXiaoE`（同一判据，只求值一次）。
+     * 判据：桌面客户端可由 Agent 根据宿主明确上下文传入全局参数 `--runtime-agent xiaoe`；
+     * 传入环境中存在任意 `XIAOE_*` 变量时也直接判定为小e环境。
+     * 历史会话和本地文件本身不参与宿主身份判断。
+     * 本处复用上面算好的 `isXiaoE`（同一判据，只求值一次）。
      *
      * 本档**不跑字段联动、也不跑显示属性联动**（2026-10-16 用户裁定，见上方 `isXiaoE` 的注释）：
      * 所以这里既没有「字段联动带出」的提示，`hiddenSubforms` / `rowExtraRequired` / `rowDisabled`
@@ -4538,16 +5120,22 @@ async function commandCreateRequest(args, env) {
         // `src` 要的是绝对地址：句柄里带走的那份 baseUrl 为准（与句柄同源，避免"换了域名后旧句柄拼出别的站"），
         // 旧版本句柄可能没带 ⇒ 回落到当前会话的 baseUrl。
         const xiaoEBaseUrl = String(context.baseUrl ?? '') || (await getSessionContext(env)).baseUrl;
+        // 交给页面的值：`createRequestDirect` 这一档先按显示属性联动过滤掉不可编辑字段（见上方 options 注释），
+        // 其余入口（`createRequest`）原样传 `preview`。
+        const fillPreview = options.xiaoEViewLinkageFilter
+            ? editablePreviewForXiaoE(preview, fields, { hiddenSubforms, rowHidden, rowDisabled, hiddenFieldIds })
+            : preview;
         return workflowSuccess('workflow.createRequest', {
             status: 'BROWSER_FILL',
             contextId: token,
-            message: '当前是小e环境：本次不向服务端写入，改由浏览器页面完成填单。命令已把 <browsertool> 标签块直接输出到 stdout（本档不打 JSON 信封），把那段输出原样作为本轮回复正文即可（不要包在代码块里、不要加任何前后说明）。',
+            // 本档只有一种输出形态（JSON 信封），指引也就只有一条：从 `data.finalMarkdown` 取内容。
+            message: '当前是小e环境：本次不向服务端写入，改由浏览器页面完成填单。本档输出的是 JSON 信封（额外带 durationMs / apiDurations / authMs 耗时），`data.finalMarkdown` 就是那段 <browsertool> 标签块（其中的换行在 JSON 里以 \\n 转义）。把 `data.finalMarkdown` 的内容原样作为本轮回复正文：从 <browsertool> 到 </browsertool>、换行还原成真实换行，不要包在代码块里、不要加任何前后说明；JSON 信封本身不要回给用户。',
             workflow: context.workflow,
             finalMarkdown: renderXiaoEFillFormMarkdown({
                 baseUrl: xiaoEBaseUrl,
                 title: String(context.workflow?.name ?? ''),
                 workflowId: String(context.workflow?.id ?? context.runtime?.workflow_id ?? ''),
-                customParams: xiaoECustomParams(preview),
+                customParams: xiaoECustomParams(fillPreview),
             }),
         });
     }
@@ -4557,11 +5145,18 @@ async function commandCreateRequest(args, env) {
         // 同时给一份可直接原样粘贴的渲染档（V12.1.102）：结论 + 主表「已填内容」两列表（含流程标题与
         // 表单默认值，2026-10-14 起）+ 明细 Excel 列 + 待补必填项清单。模型不必自己拼这些表格，也不必再
         // 遍历 `resolvedValues` 拼待补清单；因此这里**不再返回** `resolvedValues`（渲染素材只在命令内部用）。
-        const pendingRequestName = String(args.requestName ?? sysDefaults.requestName ?? context.runtime.default_request_name ?? '').trim();
+        const pendingRequestName = firstNonEmptyString([
+            args.requestName,
+            sysDefaults.requestName,
+            context.runtime.default_request_name,
+        ]);
+        // ★ 2026-10-20 用户裁定：**有 `finalMarkdown` 的状态不再返回 `message`**。
+        // 这条路一定有渲染档（`renderCreatePendingMarkdown` 至少输出结论句 + 待补清单），
+        // 而 `message` 说的是同一件事、口气还是"对模型下指令"（"带同一 context 重发 action=submit"），
+        // 模型看到就会在 `finalMarkdown` 之外多输出一段、顺带把内部机制漏给用户。
         return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_INPUT',
             contextId: token,
-            message: '缺少必填字段，本次未发起流程。请把下面这些字段一次问齐后，带同一 context 重发 action=submit。',
             missingFields: missingAll,
             finalMarkdown: renderCreatePendingMarkdown({ missingFields: missingAll, linkageResult }, 
             // 标题行按"当前还没填到标题"的口径取（可能为空 ⇒ 不出现该行），与落地档的 `requestName` 兜底分开。
@@ -4575,7 +5170,13 @@ async function commandCreateRequest(args, env) {
             ...folderPayload,
         });
     }
-    const requestName = String(args.requestName ?? sysDefaults.requestName ?? context.runtime.default_request_name ?? context.workflow.name ?? '新建流程').trim();
+    const requestName = firstNonEmptyString([
+        args.requestName,
+        sysDefaults.requestName,
+        context.runtime.default_request_name,
+        context.workflow.name,
+        '新建流程',
+    ]);
     if (!requestName)
         throw workflowValidationError('input_invalid', 'request_name 不能为空');
     const inputFieldIds = [...new Set(entries.map((e) => String((e.field && e.field.id) ?? '')).filter(Boolean))];
@@ -4779,9 +5380,234 @@ async function commandCreateRequest(args, env) {
     // 标题行用**本次真正落库的** `requestName`（与 `prepared.requestName` 同源），不再是"可能为空"的口径。
     if (['CREATED', 'CREATED_SUBMITTED', 'CREATED_SUBMIT_FAILED'].includes(String(result.status))) {
         result.finalMarkdown = renderCreateResultMarkdown(result, [...filledTitleRows(requestName), ...filledFieldRows]);
+        // ★ 渲染档的**结论句就是 `message`**（`renderCreateResultMarkdown` 第一行取的它），所以只能在
+        // 渲染之后再摘键——不是不用它，是**不单独返回它**：返回面里 `message` 与 `finalMarkdown` 说的
+        // 是同一句话，模型只会挑一个输出，留着就是给自己制造"两个声音"（2026-10-20 用户裁定）。
+        delete result.message;
     }
     return workflowSuccess('workflow.createRequest', result);
 }
+// ---------------------------------------------------------------------------
+// 接口耗时（`workflow.createRequestDirect`）
+// ---------------------------------------------------------------------------
+/**
+ * 接口**简称**：`path` → 模型看得懂的短名。
+ *
+ * 只登记这条命令真会打到的接口（解析工作流 / 载入表单 / 联动 / 写库 / 校验 / 浏览按钮）；
+ * 没登记的按路径最后一段兜底，不会因为漏登记就把计时丢掉。
+ */
+const API_SHORT_NAMES = {
+    [FORM_ENDPOINTS.workflowCreateList]: 'newFlowList',
+    [FORM_ENDPOINTS.loadBase]: 'loadBase',
+    [FORM_ENDPOINTS.loadFrame]: 'loadFrame',
+    [FORM_ENDPOINTS.loadMinor]: 'loadMinor',
+    [FORM_ENDPOINTS.formLayout]: 'formLayout',
+    [FORM_ENDPOINTS.tenantSetting]: 'tenantSetting',
+    [FORM_ENDPOINTS.fdLinkage]: 'fdLinkage',
+    [FORM_ENDPOINTS.save]: 'saveFormData',
+    [FORM_ENDPOINTS.create]: 'flowCreate',
+    [FORM_ENDPOINTS.flowSubmit]: 'flowSubmit',
+    [FORM_ENDPOINTS.signInputInfo]: 'signInputInfo',
+    [FORM_ENDPOINTS.submit]: 'submitRequest',
+    [FORM_ENDPOINTS.nameToId]: 'relateName2Id',
+    [FORM_ENDPOINTS.verifyNodeFieldByList]: 'verifyNodeField',
+    [FORM_ENDPOINTS.conformanceSet]: 'conformanceSet',
+    [FORM_ENDPOINTS.verificationRequestData]: 'verificationRequestData',
+    [FORM_ENDPOINTS.verificationConditionRule]: 'verificationConditionRule',
+    [WORKFLOW_ENDPOINTS.MINE_TREE]: 'mineTree',
+    [WORKFLOW_ENDPOINTS.MEMORY_PROMPT]: 'memoryPrompt',
+    [WORKFLOW_ENDPOINTS.WORKFLOW_PATH_BROWSER]: 'workflowPathBrowser',
+    [WORKFLOW_ENDPOINTS.RESOURCE_BROWSER]: 'resourceBrowser',
+    [WORKFLOW_ENDPOINTS.HRM_RESOURCE_BROWSER]: 'hrmResourceBrowser',
+    [WORKFLOW_ENDPOINTS.DEPT_BROWSER]: 'deptBrowser',
+    [WORKFLOW_ENDPOINTS.SUBCOMPANY_BROWSER]: 'subcompanyBrowser',
+    [WORKFLOW_ENDPOINTS.GROUP_BROWSER]: 'groupBrowser',
+    [WORKFLOW_ENDPOINTS.ROLE_BROWSER]: 'roleBrowser',
+    [WORKFLOW_ENDPOINTS.POSITION_BROWSER]: 'positionBrowser',
+    [WORKFLOW_ENDPOINTS.NODE_BROWSER]: 'nodeBrowser',
+    [WORKFLOW_ENDPOINTS.FIELD_OPTION_BROWSER]: 'fieldOptionBrowser',
+    [WORKFLOW_ENDPOINTS.REQUEST_DETAIL]: 'getWorkflowRequest',
+    // 智能填参（非 workflow 前缀，靠 `aiappuniquekey` 头定位智能体应用，见 chatscene.ts）
+    '/api/ai/application/chat/chatScene': 'chatScene',
+};
+function apiShortName(path) {
+    const text = String(path ?? '');
+    const known = API_SHORT_NAMES[text];
+    if (known)
+        return known;
+    const segments = text.split('/').filter(Boolean);
+    return segments.length ? segments[segments.length - 1] : text || 'unknown';
+}
+/**
+ * 给 host 套一层**逐接口计时**（只包请求，不改返回、不吞异常）。
+ *
+ * `finally` 里落片段：请求失败（超时 / 业务错误 / 抛错）同样要记 —— 恰恰是这类请求最需要看到耗时。
+ */
+function withApiTiming(host, spans) {
+    const record = async (path, run) => {
+        const start = Date.now();
+        try {
+            return await run();
+        }
+        finally {
+            spans.push({ name: apiShortName(path), start, end: Date.now() });
+        }
+    };
+    return {
+        ...host,
+        workflowRequest: (request) => record(request?.path, () => host.workflowRequest(request)),
+        workflowBinaryRequest: (request) => record(request?.path, () => host.workflowBinaryRequest(request)),
+    };
+}
+/**
+ * 把逐次请求的片段收成「一条命令里每个接口花了多久」。
+ *
+ * 口径（2026-10-21 用户裁定）：
+ * - **并行**（时间区间重叠）的接口合成**一个 key**：各简称用 `_` 拼起来（多个时按字母序，保证同一批
+ *   接口每次输出同一个 key），**值取这一批的墙钟耗时**（最早开始 → 最晚结束），**不是**把批内每个
+ *   接口的耗时相加；
+ * - 串行接口各自一个 key，值就是它自己的耗时；
+ * - 同一个 key 出现多次（同一接口被调了两轮）按累加计 —— 那确实是两笔独立开销。
+ *
+ * 重叠判定用「区间扫描」而不是推断代码里的并发结构：只要两个请求在时间上真重叠就算一批，
+ * 批量接口内部再起并发也照样能反映出来。
+ *
+ * ★ 2026-10-22 用户裁定：**并行批还要记「谁最慢」**（`apiSlowest`）。批的墙钟只说明"这一批花了多久"，
+ * 看不出是哪个接口把它拖住的；而优化恰恰只对最慢的那个有用。判定口径：
+ * - 只对**真并行**（批内 ≥ 2 个请求）的批产出一条，单一请求的批不产 —— 那种情况下"谁最慢"就是它自己，
+ *   记了只是噪声；
+ * - 批内**全是同一个接口**时也不产（如 5 个并发的 `getWorkflowRequest` 取历史详情）：请求都一样，
+ *   "谁最慢"没有区分意义，只有批的墙钟有用（2026-10-22 用户第二轮裁定）；
+ * - `ms` 取该接口**自身**耗时（`end - start`），不是批墙钟；
+ * - 每条另带 `items`：批内**每个**成员的 `{name, at, ms}`（`at` 相对批起点），按 `ms` 降序。
+ *   2026-10-26 用户要求：只看最慢项判断不出「优化它值不值」——若批内多个接口耗时接近，
+ *   砍掉最慢那个的收益有限，得看整条关键路径的分布；
+ * - 顺序＝批的时间顺序，与 `apiDurations` 的 key 一一对应。
+ */
+function summarizeApiSpans(spans) {
+    const sorted = [...spans].sort((a, b) => (a.start - b.start) || (a.end - b.end));
+    const groups = [];
+    let current = [];
+    let reach = Number.NEGATIVE_INFINITY;
+    for (const span of sorted) {
+        // 端点相接（`start === reach`）按串行算：前一个已经返回，后一个才开始。
+        if (current.length && span.start < reach) {
+            current.push(span);
+            reach = Math.max(reach, span.end);
+        }
+        else {
+            if (current.length)
+                groups.push(current);
+            current = [span];
+            reach = span.end;
+        }
+    }
+    if (current.length)
+        groups.push(current);
+    const durations = {};
+    const slowest = [];
+    for (const group of groups) {
+        const names = group.map((item) => item.name);
+        const key = names.length === 1 ? names[0] : [...names].sort().join('_');
+        const cost = Math.max(0, Math.round(Math.max(...group.map((item) => item.end)) - Math.min(...group.map((item) => item.start))));
+        durations[key] = (durations[key] ?? 0) + cost;
+        // 批内全是同一个接口 ⇒ 不产最慢项（"5 个 getWorkflowRequest 里谁最慢"没有区分意义）。
+        if (group.length > 1 && new Set(names).size > 1) {
+            const origin = Math.min(...group.map((item) => item.start));
+            // 批内逐个成员都留一条（`at` 相对批起点，`ms` 自身耗时），按耗时降序；并列取先开始的
+            // （`at` 升序），保证同一份输入每次输出一致。`name`/`ms` 就取这一项。
+            const items = group
+                .map((item) => ({
+                name: item.name,
+                at: Math.max(0, Math.round(item.start - origin)),
+                ms: Math.max(0, Math.round(item.end - item.start)),
+            }))
+                .sort((a, b) => (b.ms - a.ms) || (a.at - b.at));
+            slowest.push({ batch: key, name: items[0].name, ms: items[0].ms, items });
+        }
+    }
+    return { durations, slowest };
+}
+/**
+ * `workflow.createRequestDirect` —— **取数命令**（2026-10-22 用户裁定，语义已变）。
+ *
+ * 原先是「载入表单 + 智能填参 + 发起」一步到位；现在**只返回填参原料**，由调用方（桌面端 agent
+ * 自己的模型）拼好 `data` 再调 `createRequest`。理由：那一侧本身就是模型，再往 CLI 里跑一趟
+ * `chatScene` 只是白白多一次模型调用与一轮上下文。
+ *
+ * ## 五条口径
+ * 1. **不调 `chatScene`**：它复用的取数段（`prepareCreateFormPayload`）自 2026-10-23 起就不再碰
+ *    这条链路（`createForm` 已不接 `userQuestion`），本命令无需再做什么就能保证「一个请求都不发」。
+ * 2. **不发起、不写库**：不调用 `commandCreateRequest`，一条 `saveFormData` / `flow/create` 都不会发。
+ *    这条命令的 `risk` 因此从 `high-risk-write` 降为 `read`。
+ * 3. **只返回填参原料**：`fields`（含 `initialValue`）、`historyRequestData`、`userMemory`
+ *    （＝该工作流的记忆 `workflowMemory`），外加 `status` / `workflow` 两个元信息。
+ * 4. **不返回系统字段**：`systemFields` / `systemFieldWarning` 整块不出现（标题/紧急程度/密级的默认值
+ *    与选项清单都不给）。
+ * 5. **输出降级**（按 20,000 **字符**，与 `createForm` 同一个宿主口径）：
+ *    全量超线 ⇒ `historyRequestData` 留空数组（键还在）；仍超 ⇒ `userMemory` 留空串（键还在）；
+ *    **`fields` 自己也超线时不再裁**（宁大不丢）—— 它是唯一不可省的，砍了这条命令就没有意义。
+ *
+ * ## 耗时
+ * 与 `createForm` 完全同口径，全部收在 `timing` 一个桶里：`durationMs`（整条命令）/
+ * `apiDurations`（按并行批合并的接口耗时）/ `apiSlowest`（每个真并行批的最慢项，`items` 里带批内
+ * 每个接口各自的耗时）/
+ * `authMs`（会话解析）。本命令不会出现 `fillDurationMs` —— 那一项统计的是 `chatScene`，不再有这一段。
+ */
+async function commandCreateRequestDirect(args, env) {
+    const startedAt = Date.now();
+    // 计时从**命令入口**开始算（含会话解析、工作流消歧、表单载入）。
+    const spans = [];
+    const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    // 取数段本身已经不碰 `chatScene`（`createForm` 自 2026-10-23 起不再接 `userQuestion`），
+    // 这里不必再置空任何入参。
+    const { payload, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    const contextId = String(payload.contextId ?? '');
+    if (!contextId) {
+        // `prepareCreateFormPayload` 正常返回时 contextId 必然存在；这里只用来判断
+        // "表单到底载入成功没有"（句柄本身不再交给调用方）。
+        throw workflowValidationError('context_missing', '表单载入未产出可用句柄，请重试');
+    }
+    const { durations: apiDurations, slowest: apiSlowest } = summarizeApiSpans(spans);
+    // 返回面只留「模型真正要用的」：状态 + 工作流 + 填参三样 + 一个耗时桶。
+    // 句柄类（contextId/requestId/requestName）、`form`、`continuation`、`requiredInfoWarning` 全部不出
+    // —— 本命令不发起，这些字段没有下游（2026-10-22 用户裁定）。`contextId` 仍在上面的守卫里用于
+    // 判断"表单到底载入成功没有"，只是不再交出去。
+    const data = {
+        status: payload.status,
+        workflow: payload.workflow,
+        fields: payload.fields,
+        historyRequestData: payload.historyRequestData,
+        userMemory: String(payload.workflowMemory ?? ''),
+    };
+    // 判线必须把「稍后才求得出」的耗时键先按位数占住（与 `createForm` 同一个哨兵口径，宁可高估），
+    // 否则边界上的表单会被判成"没超"、然后在宿主那儿被真截断。
+    const reserve = {
+        timing: {
+            durationMs: DURATION_RESERVE_SENTINEL,
+            apiDurations,
+            apiSlowest,
+            authMs: DURATION_RESERVE_SENTINEL,
+        },
+    };
+    const overLine = () => finalStdoutChars({ ...data, ...reserve }, 'workflow.createRequestDirect') > CREATE_FORM_STDOUT_SAFE_CHARS;
+    // 两级降级：先砍历史（留空 key）→ 再砍记忆（留空 key）。`fields` 不参与裁剪。
+    if (overLine()) {
+        data.historyRequestData = [];
+        if (overLine())
+            data.userMemory = '';
+    }
+    return workflowSuccess('workflow.createRequestDirect', {
+        ...data,
+        // 全部耗时口径收进一个桶：总耗时、逐接口耗时、并行批最慢项、登录耗时。
+        timing: {
+            durationMs: Date.now() - startedAt,
+            apiDurations,
+            apiSlowest,
+            authMs,
+        },
+    });
+}
 function formatRemark(value) {
     const text = String(value ?? '').trim();
     if (!text)
@@ -4900,10 +5726,17 @@ function buildCreateBody(context, prepared, saved, src) {
  *   - 多带 `operResultType`/`userSpecifiedNodeId`/`needAutoOpen`/`autoMaxDisplay`/`testParam`/
  *     `seconedSubmit`（字段名本来就少一个 n，照抄不改）。
  */
-function buildSubmitBody(context, prepared, view) {
+function buildSubmitBody(context, prepared, view, 
+/**
+ * 已经按默认样式包好的签字意见（见 `sign-input.ts`）。
+ *
+ * 不传则退回 `formatRemark` 的老形态 —— 只有"确实要提交、且内容非空"的那一档才会传，
+ * 空意见与降级路径仍是 `_weaverMte_`，与历史完全一致。
+ */
+wrappedRemark) {
     const runtime = context.runtime;
     const requestId = String(runtime.request_id ?? '');
-    const remark = formatRemark(prepared.remark);
+    const remark = wrappedRemark ?? formatRemark(prepared.remark);
     return {
         operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE',
         userSpecifiedNodeId: '0',
@@ -5151,13 +5984,18 @@ async function loadCreateSubmitContext(env, context, requestLevel) {
  * 连接中断同样按"提交结果不确定"如实回报；**认证错误照规则原样抛**，不降级成数据结论。
  */
 async function submitCreatedRequest(env, context, prepared, view) {
+    // 提交前先按租户配置把签字意见包成带默认字体/字号的形态（发起流程 ⇒ `isCreate:1` + `workflowId`）。
+    // 取不到样式时 `resolveSignRemark` 内部已退回老形态，不会阻断提交。
+    const signRemark = await resolveSignRemark(env, prepared.remark, {
+        workflowId: String(context.workflow?.id ?? ''),
+    });
     let response;
     try {
         response = await env.host.workflowRequest({
             method: 'POST',
             path: FORM_ENDPOINTS.flowSubmit,
             query: { requestId: String(context.runtime.request_id ?? '') },
-            body: buildSubmitBody(context, prepared, view),
+            body: buildSubmitBody(context, prepared, view, signRemark),
             operation: 'workflow.createRequest',
         });
     }
@@ -5648,7 +6486,7 @@ async function commandEditPrepare(args, env) {
         });
     }
     const merged = mergeDetails(context.currentDetails || [], details);
-    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true);
+    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true, context.currentDetails || []);
     const merged2 = mergeLinkageDetails(merged, linkageDetails);
     const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
     const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
@@ -5822,7 +6660,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 + 该工作流的发起偏好。只取数、不填参（不再调智能体）：模型据此自己拼 data 后交给 createRequest',
     capability: 'create',
     risk: 'read',
     requiresConfirmation: false,
@@ -5830,9 +6668,8 @@ const workflowCreateForm = {
         workflow: {
             type: 'array',
             items: { type: 'string' },
-            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用英文逗号分隔，如 "报销,报销流程")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；0 命中或多命中且无全名精确匹配时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
+            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用中英文逗号分隔，如 "请假,请假申请")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；未能唯一确定目标时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
         },
-        relatesTo: { type: 'string', description: '可选关联对象 id（仅透传，不影响表单初始化）' },
     }, { required: ['workflow'] }),
     handler: (args, env) => commandCreateForm(args, env),
 };
@@ -5854,13 +6691,31 @@ const workflowCreateRequest = {
         },
         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）' },
+        requestLevel: { type: 'string', description: '紧急程度：用户原话即可（如「紧急」「普通」），CLI 按选项名归一成编码；说不出就不传，走表单默认值' },
+        secLevel: { type: 'string', description: '密级：用户原话即可（如「机密」「公开」），CLI 按选项名归一成密级 id；说不出就不传，走表单默认值' },
         remark: { type: 'string', description: '签字意见' },
         verificationConfirmed: { type: 'boolean', description: '节点字段校验需用户确认时显式确认继续提交' },
     }, { required: ['context', 'data', 'action'] }),
     handler: (args, env) => commandCreateRequest(args, env),
 };
+const workflowCreateRequestDirect = {
+    name: 'workflow.createRequestDirect',
+    resource: 'workflow',
+    method: 'createRequestDirect',
+    action: 'workflow.createRequestDirect',
+    summary: '取数（不发起、不调智能体、不写库）：载入发起表单后直接返回 fields（含 initialValue）、historyRequestData、userMemory，供你拼好 data 后再调 createRequest。不返回系统字段（标题/紧急程度/密级的默认值与选项），也不返回句柄、form、continuation。输出超过 2 万字符时依次降级：先让 historyRequestData 变成空数组，仍超再让 userMemory 变成空串（键都保留）。耗时全部收在 timing 一个键里：{durationMs, apiDurations, apiSlowest, authMs}',
+    capability: 'read',
+    risk: 'read',
+    requiresConfirmation: false,
+    inputSchema: schemaOf({
+        workflow: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '工作流条件：支持 "名称(ID)"、名称（可传多个，用英文逗号分隔）、纯数字 ID；语义与 createForm 的 workflow 完全一致（含澄清规则）',
+        },
+    }, { required: ['workflow'] }),
+    handler: (args, env) => commandCreateRequestDirect(args, env),
+};
 const workflowEditLoad = {
     name: 'workflow.editLoad',
     resource: 'workflow',
@@ -5910,6 +6765,7 @@ const workflowEditApply = {
 export const workflowFormOperations = [
     workflowCreateForm,
     workflowCreateRequest,
+    workflowCreateRequestDirect,
     workflowEditLoad,
     workflowEditPrepare,
     workflowEditApply,