weaver-work-cli 0.1.25 → 0.1.26

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,99 @@ function singleExplicitWorkflowId(rawWorkflow) {
     const parsed = parseNameWithId(terms[0]);
     return parsed.id ?? (/^[0-9]+$/.test(terms[0]) ? terms[0] : '');
 }
-/** 表单载入 + 该工作流的发起偏好：两者只共享 `workflowId`，可以并行。 */
+/** 表单载入 + 该工作流的记忆：两者只共享 `workflowId`，可以并行。 */
 async function loadCreateFormPack(workflowId, env) {
-    const [{ data }, launchPreferences] = await Promise.all([
+    const [{ data }, workflowMemory] = await Promise.all([
         buildCreateFormData(workflowId, env),
         // 记忆读取是 best-effort（内部全 catch），不会把表单载入的错误顶掉。
-        fetchLaunchPreferences(workflowId, env),
+        fetchWorkflowMemory(workflowId, env),
     ]);
-    return { data, launchPreferences };
+    return { data, workflowMemory };
 }
-async function commandCreateForm(args, env) {
-    // ★ 2026-10-16 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
-    // 起点取在函数入口（含下面那次会话惰性初始化），终点取在结果产出之后 —— 即"从命令开始执行到
-    // 执行完成"。取值不做开关、不进 skill 文档（用户明确要求"直接默认加上"）。
-    const startedAt = Date.now();
+/**
+ * 智能填参：把「用户意图 + 表单字段上下文」交给独立智能体（`chatScene`），换回可直接使用的 `data`。
+ *
+ * ## 什么时候调
+ *
+ * 两个条件**同时**成立才调，缺一就原样返回（= 老行为）：
+ * 1. 调用方给了 `userQuestion`（非空）—— 空串时智能体没有可依据的意图，接口也回不出有效结果，
+ *    所以仍以它为前置（2026-10-20 用户裁定）；
+ * 2. 拿到了 `baseUrl`（真连上了 OA）。
+ *
+ * **不看小e 档**（2026-10-20 用户裁定）：以前这一档被跳过，理由是"填单发生在宿主页面、算了也没人用"；
+ * 现在照走 —— 走通时 `createForm` 直接把算好的 `data` 交给模型，页面填单同样能用上。
+ *
+ * ## 失败怎么处理
+ *
+ * `requestFormFill` 内部吞掉所有异常并返回 `ok:false`，这里**直接不当回事**：返回
+ * `applied:false`，调用方照旧回 `historyRequestData` / `systemFields`。智能体挂掉不能把
+ * 发起流程打死 —— 这是本功能唯一的硬约束。
+ *
+ * ## 传什么记忆
+ *
+ * `userMemory` 用该工作流的记忆（`workflowMemory`）。它是
+ * **一段 Markdown 文本**，不是键值对象（2026-10-19 用户裁定）。全局画像由入口处的
+ * `workflow.memoryPrompt` 覆盖，这里不重复取。
+ */
+async function resolveIntentFill(pack, userQuestion, baseUrl, env) {
+    const question = String(userQuestion ?? '').trim();
+    // ★ 2026-10-20 用户裁定（口径修正）：前置**只有两条** ——「`userQuestion` 非空」+「连上了 OA」。
+    // `userQuestion` 为空时智能体没有可依据的意图、接口也回不出有效结果，故照旧不调；
+    // **小e 档不再豁免**（此前 `hasXiaoEEnv` 直接关掉这条链路，现已按用户要求去掉）。
+    // 走通与否仍由接口结果决定：回不出可用的 `data.chatMessage.content`（JSON）就 `applied:false`。
+    if (!question || !baseUrl)
+        return { applied: false };
+    const fields = Array.isArray(pack.data.fields) ? pack.data.fields : [];
+    if (!fields.length)
+        return { applied: false };
+    const input = buildChatSceneInput({
+        userQuestion: question,
+        workflow: {
+            id: String(pack.data.workflow?.id ?? ''),
+            name: String(pack.data.workflow?.name ?? ''),
+        },
+        fields,
+        historyRequestData: pack.data.historyRequestData ?? null,
+        systemFields: pack.data.systemFields ?? {},
+        userMemory: String(pack.workflowMemory ?? ''),
+        now: formatLocalNow(),
+    });
+    const outcome = await requestFormFill(env, input);
+    if (!outcome.ok || !outcome.data)
+        return { applied: false };
+    return {
+        applied: true,
+        data: outcome.data,
+        // 智能体的标题规则：有默认值时它只会给空串（沿用默认）；给了值才是用户明确要求的标题
+        requestName: String(outcome.systemData?.requestName ?? '').trim(),
+        // 供 `createRequestDirect` 把「紧急程度 / 密级 / 签字意见」一并透传给 `createRequest`；
+        // `createForm` 自己不消费这几个键（返回面一个字不变）。
+        systemData: outcome.systemData ?? {},
+        // ★ 2026-10-19 用户裁定：把「生成表单参数」这段的耗时单独带出去（只在真走通 chatScene 时才有）。
+        // 口径 = `requestFormFill` 内部这一趟（发请求 → 拿回 content → parse → 归一化），
+        // 不含本函数上游的会话初始化与表单取数 —— 那些已由 `durationMs` 计入，两者是「整条命令」与
+        // 「其中智能体这一段」的关系，不是并列的两笔开销。
+        durationMs: outcome.durationMs,
+    };
+}
+/**
+ * `createForm` 的**取数阶段**（原 `commandCreateForm` 前半段，逐行搬过来，行为一字不改）。
+ *
+ * 抽出来的唯一目的：`createRequestDirect` 需要「未经压缩、未经落盘」的原始 payload —— 那条命令要把
+ * `contextId` 与智能体算出的 `data` 直接喂给 `createRequest`，而 `commandCreateForm` 的输出可能
+ * 因为超线只剩一句"结果已落盘"的提示，取不到这两个键。
+ */
+async function prepareCreateFormPayload(args, env) {
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
     // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
-    await env.host.getSession();
+    // 顺带留住返回的上下文：智能填参要用它的 `baseUrl` 判「是不是真连了 OA」。
+    //
+    // 顺带计时：登录取凭据（小e 环境下是 `tokens.py` 换 eteamId + `teamsCheck` 换登录人这一整套）
+    // 走的是 auth 层自己的 fetch，不经 `host.workflowRequest` ⇒ 天然落在 `apiDurations` 之外。
+    // 这一段的耗时单独带出去（`authMs`），否则「总耗时 − 各接口」会凭空多出几百毫秒对不上账。
+    const authStartedAt = Date.now();
+    const sessionCtx = await env.host.getSession();
+    const authMs = Date.now() - authStartedAt;
     let target;
     let pack;
     const explicitId = singleExplicitWorkflowId(args.workflow);
@@ -1691,22 +1861,83 @@ 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 } : {}),
+        },
+    };
+    // 该工作流的记忆：**一段 Markdown 原文**，读不到就不出这个键（模型见到"没有这个键"就按新用户处理）。
+    if (pack.workflowMemory)
+        fullPayload.workflowMemory = pack.workflowMemory;
+    // ★ 2026-10-19 用户裁定：`createForm` 在返回前调 `chatScene`，由独立智能体把用户意图直接算成
+    // `data` 参数。成功时返回面收窄为「记忆（workflowMemory）+ fields + data」：
+    //   - `historyRequestData` 删除（历史值已由智能体消化进 data，再发一份只会让模型二选一）
+    //   - `systemFields` / `systemFieldWarning` 删除（智能体已按默认值 + 选项约束算过标题与紧急程度）
+    //   - `requiredInfoWarning` **保留**：它不是 systemFields 的内容，而是「OA 没下发静态字段权限，
+    //     照常按 missingFields 补齐」这条**行为指引**；删掉会让模型在未下发权限的表单上误判。
+    // 失败（含小e 档、未传 userQuestion）⇒ 一个字都不改，原样走老口径。
+    const fill = await resolveIntentFill(pack, String(args.userQuestion ?? ''), sessionCtx.baseUrl, env);
+    if (fill.applied) {
+        delete fullPayload.historyRequestData;
+        delete fullPayload.systemFields;
+        delete fullPayload.systemFieldWarning;
+        fullPayload.data = fill.data;
+        // 智能体只在「用户明确要求标题」时才给非空值；它给了才覆盖 createForm 的默认标题
+        if (fill.requestName)
+            fullPayload.requestName = fill.requestName;
+    }
+    return { payload: fullPayload, fill, authMs };
+}
+async function commandCreateForm(args, env) {
+    // ★ 2026-10-16 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
+    // 起点取在函数入口（含下面那次会话惰性初始化），终点取在结果产出之后 —— 即"从命令开始执行到
+    // 执行完成"。取值不做开关、不进 skill 文档（用户明确要求"直接默认加上"）。
+    const startedAt = Date.now();
+    // ★ 2026-10-21 用户裁定：耗时口径与 `createRequestDirect` **完全一致** —— 除总耗时外再给
+    // 「每个接口多久」（`apiDurations`）与「登录取凭据多久」（`authMs`）。所以这里也把 host 包一层
+    // 逐接口计时，整条命令（含智能填参那一趟）的请求都会被记上。
+    const spans = [];
+    const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    const { payload: fullPayload, fill, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    // 取数阶段已全部结束 ⇒ 这里拿到的是完整的一份；它既是判线要预留的键，也是最终返回的值。
+    const apiDurations = summarizeApiSpans(spans);
+    // 判线的位数预留：`durationMs` / `apiDurations` / `authMs` 一定会有；`fillDurationMs` **只有走通
+    // chatScene 才有**，所以只在它会出现的这一轮才占位 —— 否则没走智能体时也白占十几个字符，边界上
+    // 会让本可内联的表单提前落盘。`apiDurations` 此刻已经求出，直接按真值占（不必用哨兵估）。
+    const reserve = {
+        durationMs: DURATION_RESERVE_SENTINEL,
+        apiDurations,
+        authMs: DURATION_RESERVE_SENTINEL,
     };
-    const compacted = await compactFormOutput(fullPayload, env, 'last_create_form.json', [], {
+    if (fill.durationMs !== undefined)
+        reserve.fillDurationMs = DURATION_RESERVE_SENTINEL;
+    const compacted = await compactFormOutput(fullPayload, timedEnv, 'last_create_form.json', [], {
         safeChars: CREATE_FORM_STDOUT_SAFE_CHARS,
         operation: 'workflow.createForm',
-        // 判线要量"最终打出去的那份文本"，而 `durationMs` 的真值只能在压缩**之后**求（它统计的正是
-        // 整条命令），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘（安全方向）。
-        reserve: { durationMs: DURATION_RESERVE_SENTINEL },
+        // 判线要量"最终打出去的那份文本"，而 `durationMs` / `fillDurationMs` 的真值只能在压缩**之后**求
+        // （它们统计的正是这段时间），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘
+        // （安全方向）。
+        reserve,
     });
     // 耗时并在 `data` 里（与 `outputChars` / `persistedResult` 这些运行期属性同处）；**两条分支都带上**
     // —— 超线落盘那一档 `data` 只剩一句提示，并进去它才不会恰好在"大表单"时消失。
-    return workflowSuccess('workflow.createForm', { ...compacted, durationMs: Date.now() - startedAt });
+    const result = {
+        ...compacted,
+        durationMs: Date.now() - startedAt,
+        apiDurations,
+        authMs,
+    };
+    // `fillDurationMs`（生成表单参数的耗时）**只在真走通 chatScene 时出现**：失败降级走的是老口径，
+    // 返回面必须一个字都不多（对应需求「不符合预期则仍按原本逻辑执行和返回」）。
+    if (fill.durationMs !== undefined)
+        result.fillDurationMs = fill.durationMs;
+    return workflowSuccess('workflow.createForm', result);
 }
 // ---------------------------------------------------------------------------
 // createForm：loadBase/loadFrame/loadMinor/formLayout + 字段输出 + fileUploadParams
@@ -1856,7 +2087,7 @@ async function buildCreateFormData(workflowId, env) {
      * 小e 环境下两处都不跑（`createRequest` 同档也跳过字段联动与显示属性联动，由浏览器页面自己算）。
      * 非小e 环境行为不变。
      */
-    if (!hasXiaoEEnv(env.ctx.env) && linkageActions.length) {
+    if (!hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.()) && linkageActions.length) {
         const loadEntries = _entriesFromDefaults(defaults);
         try {
             onLoadLinkage = await runFieldLinkage(env, buildLinkageContext({ runtime, frame, layout: { form_id: frame.form_id }, linkageActions }), loadEntries, new Set(['onLoadForm']), defaults);
@@ -2372,6 +2603,23 @@ function splitValueAliases(raw) {
     }
     return out;
 }
+/**
+ * 一个格子要送去查候选的「说法」清单——**按字段是单选还是多选分叉**：
+ *
+ *   - **单选**：整串与各说法一并登记，由 `resolveBrowserAliases` 的「整串优先」先试整串
+ *     （名称本身自带逗号时不会被拆错）；
+ *   - **多选**：逗号是**值分隔符**，只拆不拼——整串既不做「整串优先」，也**不进候选池**。
+ *     否则「张三,李四」会被整串当成一个名称，恰好命中就静默吞成一个值（真机问题：
+ *     多选浏览字段只写进去第一个对象），而且还会白花一次 complete / nameToId 往返。
+ *
+ * 多选里若单个对象名真的自带逗号，由 `名称(ID)` 显式指定（`resolveBrowserAliases` 认它）。
+ */
+function lookupTermsOf(field, raw) {
+    const aliases = splitValueAliases(raw);
+    if (field && field.isMultiple)
+        return aliases.length ? aliases : [raw];
+    return aliases.length > 1 ? [raw, ...aliases] : [raw];
+}
 /** 浏览按钮字段解析不出来的统一出口。`candidates` **只含关键词真实命中**，绝不用首页枚举冒充。 */
 function browserAmbiguity(field, input, hits) {
     return new ValueAmbiguity({
@@ -2421,8 +2669,11 @@ function resolveBrowserAliases(field, raw, lookup) {
         return out;
     };
     const aliases = splitValueAliases(raw);
-    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定
-    const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+    // 整串与各说法**并行**登记：整串命中（名称自带逗号）与切段命中进同一个池子判定。
+    // 多选字段只登记切段结果（见 lookupTermsOf）。
+    const terms = lookupTermsOf(field, raw);
+    /** 「整串优先」只对**单选**成立：多选里逗号是值分隔符，整串本身不是候选名称。 */
+    const wholeTermFirst = !(field && field.isMultiple) && aliases.length > 1;
     const pool = [];
     /** 每个词各自「字面同名」的候选（显式 ID 也算字面命中，它本来就是精确值）。 */
     const literalByTerm = new Map();
@@ -2435,8 +2686,8 @@ function resolveBrowserAliases(field, raw, lookup) {
         literalByTerm.set(term, candidates.filter((c) => String(c?.name ?? '') === term));
     }
     const poolHits = dedupe(pool);
-    // ① **整串优先**：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
-    if (aliases.length > 1) {
+    // ① **整串优先**（仅单选）：原串本身就是一个名称 ⇒ 用它、不拆（名称自带逗号也不会被拆错）；真重名则澄清
+    if (wholeTermFirst) {
         const wholeHits = dedupe(literalByTerm.get(raw) || []);
         if (wholeHits.length === 1)
             return wholeHits[0];
@@ -2679,6 +2930,18 @@ function serializeValue(field, value, mappings, row, browserHints = {}) {
                 const key = `${field.id}_${rowIndex}_${term}`;
                 return { mapped: mappings[key] || [], completed: browserHints[key] || [] };
             };
+            if (field.isMultiple) {
+                // 多选：一个格子里的逗号是**值分隔符**，逐说法各解析出一条 `dataOptions`
+                // （整串不当名称，见 lookupTermsOf）。某个说法有歧义时整条值都不落地，
+                // 由该说法自己的候选澄清——已解析出的兄弟值**不丢**，因为澄清后会整条重发。
+                for (const term of lookupTermsOf(field, raw)) {
+                    const pickedOne = resolveBrowserAliases(field, term, lookup);
+                    if (options.some((o) => o.optionId === pickedOne.id))
+                        continue;
+                    options.push({ optionId: pickedOne.id, content: pickedOne.name });
+                }
+                continue;
+            }
             const picked = resolveBrowserAliases(field, raw, lookup);
             options.push({ optionId: picked.id, content: picked.name });
         }
@@ -2897,8 +3160,8 @@ async function resolveEntryValues(env, entries, formId) {
                 continue;
             // 一个格子可写多个「说法」（逗号分隔）：**整串与各说法一起登记**——这样"整串优先"要用的
             // 整串候选、以及各说法各自的候选，都在同一批里拿到（nameToId 一把批量发，未命中的再并行补）。
-            const aliases = splitValueAliases(raw);
-            const terms = aliases.length > 1 ? [raw, ...aliases] : [raw];
+            // 多选字段只登记切段结果（逗号是值分隔符，见 lookupTermsOf）。
+            const terms = lookupTermsOf(field, raw);
             // 候选来源二选一：控件自带 `browserModule`+`browserType` ⇒ 只走 complete（下一步补查），
             // **不进 nameToId 批次**；否则只走 nameToId。这样池子里永远只有一个来源，不会互相污染。
             const hasBrowserChannel = Boolean(field.browserModule && field.browserType);
@@ -3191,6 +3454,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 +3719,10 @@ function _mainValueMap(details) {
     }
     return result;
 }
-async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false) {
-    const changedIds = entries.filter((e) => e.field && typeof e.field === 'object' && String(e.field.id ?? '').trim())
-        .map((e) => String(e.field.id));
+async function runFieldLinkage(env, ctx, entries, actionTypes, allDetails, isEdit = false, baseline) {
+    // 只有「值与基线（发起=表单默认值 / 编辑=编辑前值）不同」的字段才算变更字段，
+    // 见 `_changedFieldIds` 的注释（2026-10-20 用户裁定：值没变就不该触发 changeField 联动）。
+    const changedIds = _changedFieldIds(entries, baseline);
     const runDataList = _buildLinkageRunData(ctx.linkageActions, changedIds, actionTypes);
     const neededIds = _neededLinkageFieldIds(ctx.linkageActions, runDataList);
     const dataList = [];
@@ -4018,7 +4423,8 @@ function mainFilledRows(fields, values, hiddenIds, disabledIds, compsFieldIds) {
  * 表格口径**，只换结论句与末段（那边要说清"还没发起 + 还差哪几项"）；`NEEDS_CONFIRMATION` 不给
  * 文本（要先解决 `ambiguities` 再重发）。
  *
- * 内容分四段：结论（`message`，命令已写好的中文）→ 编号/链接 → 主表「已填内容」两列表
+ * 内容分四段：结论（`message`，命令已写好的中文；**只用来渲染，渲染后这个键不再返回**）→ 编号/链接
+ * → 主表「已填内容」两列表
  * （系统字段如流程标题在前，业务字段按表单布局顺序随后；行由 `mainFilledRows` + `systemFilledRows`
  * 算好传进来，命令侧只有这一处口径）→ 各明细表（Excel 列形态）→ 提交失败原因 / 草稿缺项提醒（有才出现）。
  */
@@ -4262,6 +4668,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 +4783,50 @@ 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，取墙钟、不叠加）；
+ * - `authMs` = 登录取凭据（首次会话解析）的墙钟 —— 这一段走 auth 层自己的 fetch、不经
+ *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账。
+ *
+ * `data` 不是普通对象时原样返回（被替换成字符串 / 数组的返回面一个字都不动）。
+ */
+function stampCommandTimings(envelope, timing) {
+    const data = envelope?.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return envelope;
+    const mutable = data;
+    mutable.durationMs = Date.now() - timing.startedAt;
+    mutable.apiDurations = summarizeApiSpans(timing.spans);
+    mutable.authMs = timing.authMs;
+    return envelope;
+}
+/**
+ * `createRequest` 的耗时外壳：建计时通道 + 量登录耗时 + 把三个耗时键并回结果。
+ *
+ * 参数明显不合法（`action` 不对 / 没 `context`）时**不先登录** —— 那两种情况内层会直接抛
+ * 参数错，为一个注定失败的调用白走一趟统一登录不值当；真正的报错措辞仍由内层给出。
+ */
+async function commandCreateRequest(args, env, options = {}) {
+    const startedAt = Date.now();
+    const spans = options.apiSpans ?? [];
+    // `createRequestDirect` 已经把 host 包过一层（它的片段数组覆盖到表单载入那一段）⇒ 这里不能再包，
+    // 否则每个请求会被记两遍（key 里会出现重名）。
+    const timedEnv = options.apiSpans ? env : { ...env, host: withApiTiming(env.host, spans) };
+    const action = String(args.action ?? '').trim();
+    let authMs = 0;
+    if ((action === 'draft' || action === 'submit') && String(args.context ?? '')) {
+        // 会话是惰性的：内层的 `verifyContextLease` 本来也会取一次，这里只是把它**提前并单独计时**，
+        // 拿到的仍是同一份缓存，不额外多发请求。
+        const authStartedAt = Date.now();
+        await timedEnv.host.getSession();
+        authMs = Date.now() - authStartedAt;
+    }
+    const envelope = await runCreateRequest(args, timedEnv, options);
+    return stampCommandTimings(envelope, { startedAt, spans, authMs });
+}
 /**
  * `workflow.createRequest` —— **一条命令**完成「字段解析 → 联动 → 必填校验 → 保存 → 发起」。
  *
@@ -4350,7 +4838,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 +4883,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) {
@@ -4518,17 +5011,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` / `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 +5030,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),
             }),
         });
     }
@@ -4558,10 +5056,13 @@ async function commandCreateRequest(args, env) {
         // 表单默认值，2026-10-14 起）+ 明细 Excel 列 + 待补必填项清单。模型不必自己拼这些表格，也不必再
         // 遍历 `resolvedValues` 拼待补清单；因此这里**不再返回** `resolvedValues`（渲染素材只在命令内部用）。
         const pendingRequestName = String(args.requestName ?? sysDefaults.requestName ?? context.runtime.default_request_name ?? '').trim();
+        // ★ 2026-10-20 用户裁定：**有 `finalMarkdown` 的状态不再返回 `message`**。
+        // 这条路一定有渲染档（`renderCreatePendingMarkdown` 至少输出结论句 + 待补清单），
+        // 而 `message` 说的是同一件事、口气还是"对模型下指令"（"带同一 context 重发 action=submit"），
+        // 模型看到就会在 `finalMarkdown` 之外多输出一段、顺带把内部机制漏给用户。
         return workflowSuccess('workflow.createRequest', {
             status: 'NEEDS_INPUT',
             contextId: token,
-            message: '缺少必填字段，本次未发起流程。请把下面这些字段一次问齐后，带同一 context 重发 action=submit。',
             missingFields: missingAll,
             finalMarkdown: renderCreatePendingMarkdown({ missingFields: missingAll, linkageResult }, 
             // 标题行按"当前还没填到标题"的口径取（可能为空 ⇒ 不出现该行），与落地档的 `requestName` 兜底分开。
@@ -4779,9 +5280,201 @@ 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 出现多次（同一接口被调了两轮）按累加计 —— 那确实是两笔独立开销。
+ *
+ * 重叠判定用「区间扫描」而不是推断代码里的并发结构：只要两个请求在时间上真重叠就算一批，
+ * 批量接口内部再起并发也照样能反映出来。
+ */
+function summarizeApiSpans(spans) {
+    const sorted = [...spans].sort((a, b) => (a.start - b.start) || (a.end - b.end));
+    const groups = [];
+    let current = [];
+    let reach = Number.NEGATIVE_INFINITY;
+    for (const span of sorted) {
+        // 端点相接（`start === reach`）按串行算：前一个已经返回，后一个才开始。
+        if (current.length && span.start < reach) {
+            current.push(span);
+            reach = Math.max(reach, span.end);
+        }
+        else {
+            if (current.length)
+                groups.push(current);
+            current = [span];
+            reach = span.end;
+        }
+    }
+    if (current.length)
+        groups.push(current);
+    const out = {};
+    for (const group of groups) {
+        const names = group.map((item) => item.name);
+        const key = names.length === 1 ? names[0] : [...names].sort().join('_');
+        const cost = Math.max(0, Math.round(Math.max(...group.map((item) => item.end)) - Math.min(...group.map((item) => item.start))));
+        out[key] = (out[key] ?? 0) + cost;
+    }
+    return out;
+}
+/**
+ * `workflow.createRequestDirect` —— **临时命令**：把「载入表单 + 智能填参」和「发起」串成一步。
+ *
+ * 等价于「先跑 `createForm`（带 `userQuestion`），再把它的 `contextId` 与 `data` 原样交给
+ * `createRequest`」，区别只在一次进程内完成、不给模型中间态。
+ *
+ * ## 四条口径
+ * 1. **取数阶段复用** `prepareCreateFormPayload`（`createForm` 的同一段代码），所以澄清 / 表单不可发起
+ *    这类错误**原样上抛**，新命令一条都不会吞，也不会在澄清时硬着头皮发写请求。
+ * 2. 智能填参走通 ⇒ 用它算出的 `data`；**没走通（超时 / 返回体不合法 / 未传 userQuestion）⇒ 按
+ *    `data` 为空继续** —— 交给 `createRequest` 自己的必填校验去判定（`submit` 缺必填不写库、
+ *    `draft` 直接建草稿），与"模型没填任何字段就调 createRequest"完全等价。
+ * 3. **小e 档**：不跑字段联动（页面自己会重算），但**跑显示属性联动并把不可编辑字段过滤掉**
+ *    （`xiaoEViewLinkageFilter`），交出去的值只含页面真能填的字段。
+ * 4. 最终返回 **`createRequest` 的结果**（`data` 与各状态语义完全一致，`action` 仍是
+ *    `workflow.createRequest`），只额外挂三个耗时键（见下）。JSON 信封的 `operation` 是
+ *    `workflow.createRequestDirect`（由命令层盖，见 `successEnvelope`）。
+ *
+ * ## 小e 档也走 JSON（2026-10-21 用户裁定，已推广到原命令）
+ * 原命令在小e 下曾直出 `<browsertool>`，那条路会把耗时藏掉。现在**两条命令统一走 JSON 信封**：
+ * `data.finalMarkdown` 仍是同一段标签块，`data.durationMs` / `data.apiDurations` / `data.authMs`
+ * 一并可见；`message` 告知模型从 `finalMarkdown` 取内容原样回复。
+ *
+ * ## 耗时
+ * - `data.durationMs` = 命令总耗时；
+ * - `data.apiDurations` = 每个接口（并行批次合并）的耗时；
+ * - `data.authMs` = 登录取凭据（首次会话解析）的耗时 —— 这段走 auth 层自己的 fetch，不经
+ *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账
+ *   （`durationMs` ≈ `apiDurations` 合计 + `authMs` + 本地解析/渲染的零头）。
+ * 三者都只在 `data` 是普通对象时挂；本命令与 `createRequest` 用的是**同一个** `stampCommandTimings`，
+ * 差别只在时间区间（这里从命令入口起算、覆盖表单载入那一段）。
+ */
+async function commandCreateRequestDirect(args, env) {
+    const startedAt = Date.now();
+    const action = String(args.action ?? '').trim();
+    // 先校验 action 再取数：参数错就没必要白跑一趟表单载入（那是最贵的一段）。
+    if (action !== 'draft' && action !== 'submit') {
+        throw workflowValidationError('action_required', 'action 必填，且只能是 draft（仅存草稿）或 submit（提交审批）');
+    }
+    // 计时从**命令入口**开始算（含会话解析、工作流消歧、表单载入、智能填参、写库、校验）。
+    const spans = [];
+    const timedEnv = { ...env, host: withApiTiming(env.host, spans) };
+    const { payload, fill, authMs } = await prepareCreateFormPayload(args, timedEnv);
+    const contextId = String(payload.contextId ?? '');
+    if (!contextId) {
+        // `prepareCreateFormPayload` 正常返回时 contextId 必然存在；这里只是不带着空句柄去调写接口。
+        throw workflowValidationError('context_missing', '表单载入未产出可用句柄，本次未发起任何写入，请重试');
+    }
+    // ★ 智能体没给出可用 data ⇒ `{}`（不是老口径的 historyRequestData：本命令不做二次推断，
+    // 有值就用、没有就交给必填校验）。
+    const data = (fill.applied && fill.data && typeof fill.data === 'object')
+        ? fill.data
+        : {};
+    const systemData = fill.systemData ?? {};
+    const requestName = String(payload.requestName ?? '').trim();
+    const requestLevel = String(systemData.requestLevel ?? '').trim();
+    const secLevel = String(systemData.secLevel ?? '').trim();
+    const remark = String(systemData.remark ?? '').trim();
+    const envelope = await commandCreateRequest({
+        context: contextId,
+        data,
+        action,
+        // ★ 空串一律**不传键**：`createRequest` 的兜底链是 `args.x ?? sysDefaults.x ?? 句柄里的默认值`，
+        // 而 `??` 挡不住空串 —— 传 `''` 会把后面的默认值全部短路掉（`request_name 不能为空` 就是这么来的）。
+        ...(requestName ? { requestName } : {}),
+        ...(requestLevel ? { requestLevel } : {}),
+        ...(secLevel ? { secLevel } : {}),
+        ...(remark ? { remark } : {}),
+        verificationConfirmed: args.verificationConfirmed,
+    }, timedEnv, { xiaoEViewLinkageFilter: true, apiSpans: spans });
+    // 把耗时并回结果：与 `createRequest` 同一个函数、同一个口径，只是时间区间是整条命令
+    // （含会话解析、工作流消歧、表单载入、智能填参、写库、校验）。
+    return stampCommandTimings(envelope, { startedAt, spans, authMs });
+}
 function formatRemark(value) {
     const text = String(value ?? '').trim();
     if (!text)
@@ -4900,10 +5593,17 @@ function buildCreateBody(context, prepared, saved, src) {
  *   - 多带 `operResultType`/`userSpecifiedNodeId`/`needAutoOpen`/`autoMaxDisplay`/`testParam`/
  *     `seconedSubmit`（字段名本来就少一个 n，照抄不改）。
  */
-function buildSubmitBody(context, prepared, view) {
+function buildSubmitBody(context, prepared, view, 
+/**
+ * 已经按默认样式包好的签字意见（见 `sign-input.ts`）。
+ *
+ * 不传则退回 `formatRemark` 的老形态 —— 只有"确实要提交、且内容非空"的那一档才会传，
+ * 空意见与降级路径仍是 `_weaverMte_`，与历史完全一致。
+ */
+wrappedRemark) {
     const runtime = context.runtime;
     const requestId = String(runtime.request_id ?? '');
-    const remark = formatRemark(prepared.remark);
+    const remark = wrappedRemark ?? formatRemark(prepared.remark);
     return {
         operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE',
         userSpecifiedNodeId: '0',
@@ -5151,13 +5851,18 @@ async function loadCreateSubmitContext(env, context, requestLevel) {
  * 连接中断同样按"提交结果不确定"如实回报；**认证错误照规则原样抛**，不降级成数据结论。
  */
 async function submitCreatedRequest(env, context, prepared, view) {
+    // 提交前先按租户配置把签字意见包成带默认字体/字号的形态（发起流程 ⇒ `isCreate:1` + `workflowId`）。
+    // 取不到样式时 `resolveSignRemark` 内部已退回老形态，不会阻断提交。
+    const signRemark = await resolveSignRemark(env, prepared.remark, {
+        workflowId: String(context.workflow?.id ?? ''),
+    });
     let response;
     try {
         response = await env.host.workflowRequest({
             method: 'POST',
             path: FORM_ENDPOINTS.flowSubmit,
             query: { requestId: String(context.runtime.request_id ?? '') },
-            body: buildSubmitBody(context, prepared, view),
+            body: buildSubmitBody(context, prepared, view, signRemark),
             operation: 'workflow.createRequest',
         });
     }
@@ -5648,7 +6353,7 @@ async function commandEditPrepare(args, env) {
         });
     }
     const merged = mergeDetails(context.currentDetails || [], details);
-    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true);
+    const linkageDetails = await runFieldLinkage(env, { ...linkageContextFromPayload(context), requestId: context.requestId, formId: context.form_id, dataId: context.data_id, workflow: context.workflow, businessFields: context.businessFields }, entries, null, merged, true, context.currentDetails || []);
     const merged2 = mergeLinkageDetails(merged, linkageDetails);
     const attachmentFolderIds = _attachmentFolderIds(context.rawUploadFields || {}, context.attachConfigs || {}, fields, _mainValueMap(merged2));
     const folderPayload = Object.keys(attachmentFolderIds).length ? { attachmentFolderIds } : {};
@@ -5822,7 +6527,7 @@ const workflowCreateForm = {
     resource: 'workflow',
     method: 'createForm',
     action: 'workflow.createForm',
-    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好 + 本表单必填字段的历史参考值（不落业务数据）',
+    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好。传了 userQuestion 时额外调智能体把意图算成 data 参数（此时不返回 historyRequestData / systemFields）',
     capability: 'create',
     risk: 'read',
     requiresConfirmation: false,
@@ -5830,9 +6535,16 @@ const workflowCreateForm = {
         workflow: {
             type: 'array',
             items: { type: 'string' },
-            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用英文逗号分隔，如 "报销,报销流程")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；0 命中或多命中且无全名精确匹配时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
+            description: '工作流条件：支持 "名称(ID)"、名称(可传多个，用中英文逗号分隔，如 "请假,请假申请")、纯数字 ID；按当前用户**可发起**的工作流模糊匹配；未能唯一确定目标时返回澄清（候选见 candidates），确认后由你按「名称(ID)」重发（只问用户完整名称或其它可用于检索的关键词，不要向用户索取 ID）',
         },
         relatesTo: { type: 'string', description: '可选关联对象 id（仅透传，不影响表单初始化）' },
+        userQuestion: {
+            type: 'string',
+            description: '用户的填单意图（用一句话概括，可以是多轮对话汇总后的最终需求）。'
+                + '**传了才启用智能填参**：命令会在返回前把它连同字段清单交给智能体，换回已填好的 data 参数'
+                + '（此时不再返回 historyRequestData / systemFields）。'
+                + '不传 = 关闭这条链路，按原口径返回 historyRequestData 等参考值（老调用方零改动）',
+        },
     }, { required: ['workflow'] }),
     handler: (args, env) => commandCreateForm(args, env),
 };
@@ -5861,6 +6573,34 @@ const workflowCreateRequest = {
     }, { required: ['context', 'data', 'action'] }),
     handler: (args, env) => commandCreateRequest(args, env),
 };
+const workflowCreateRequestDirect = {
+    name: 'workflow.createRequestDirect',
+    resource: 'workflow',
+    method: 'createRequestDirect',
+    action: 'workflow.createRequestDirect',
+    summary: '一步发起（直接给 workflow，不必先调 createForm 取句柄；仍按 requiresConfirmation 先取得用户确认）：先按 createForm 解析工作流并载入表单、把 userQuestion 交给智能体算成 data，然后直接接着执行 createRequest（保存 → 创建 → 可选提交）；智能体没给出可用 data 时按 data 为空继续。小e 环境不跑字段联动但照跑显示属性联动、只交可编辑字段。返回结果与 createRequest 一致，另带 durationMs（总耗时）、apiDurations（每接口耗时）与 authMs（登录取凭据耗时）',
+    capability: 'create',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        workflow: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '工作流条件：支持 "名称(ID)"、名称（可传多个，用英文逗号分隔）、纯数字 ID；语义与 createForm 的 workflow 完全一致（含澄清规则）',
+        },
+        userQuestion: {
+            type: 'string',
+            description: '用户的填单意图（一句话概括，可多轮汇总）。命令会把它交给智能体算出要填的字段值后直接发起；为空或智能体没给出可用结果时，按"一个字段都没填"继续发起',
+        },
+        action: {
+            type: 'string',
+            enum: ['draft', 'submit'],
+            description: 'draft=仅保存草稿；submit=提交审批（必填缺失时不写库、一次性回报缺失项）',
+        },
+        verificationConfirmed: { type: 'boolean', description: '节点字段校验需用户确认时显式确认继续提交' },
+    }, { required: ['workflow', 'userQuestion', 'action'] }),
+    handler: (args, env) => commandCreateRequestDirect(args, env),
+};
 const workflowEditLoad = {
     name: 'workflow.editLoad',
     resource: 'workflow',
@@ -5910,6 +6650,7 @@ const workflowEditApply = {
 export const workflowFormOperations = [
     workflowCreateForm,
     workflowCreateRequest,
+    workflowCreateRequestDirect,
     workflowEditLoad,
     workflowEditPrepare,
     workflowEditApply,