weaver-work-cli 0.1.26 → 0.1.29

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

@@ -1749,7 +1749,12 @@ async function loadCreateFormPack(workflowId, env) {
 /**
  * 智能填参：把「用户意图 + 表单字段上下文」交给独立智能体（`chatScene`），换回可直接使用的 `data`。
  *
- * ## 什么时候调
+ * ★ **2026-10-23 起本函数没有调用方**（用户裁定：`createForm` 不再接 `userQuestion`、内部不再调
+ * `chatScene`，发起流程改回「`createForm` 取数 → 模型自己拼 `data` → `createRequest`」）。
+ * 连同 `chatscene.ts` 的 `requestFormFill` 一起**保留不删**，只是暂时不接回链路；要恢复时把
+ * `prepareCreateFormPayload` 里那句调用加回来即可。
+ *
+ * ## 什么时候调（恢复时生效）
  *
  * 两个条件**同时**成立才调，缺一就原样返回（= 老行为）：
  * 1. 调用方给了 `userQuestion`（非空）—— 空串时智能体没有可依据的意图，接口也回不出有效结果，
@@ -1790,7 +1795,6 @@ async function resolveIntentFill(pack, userQuestion, baseUrl, env) {
         },
         fields,
         historyRequestData: pack.data.historyRequestData ?? null,
-        systemFields: pack.data.systemFields ?? {},
         userMemory: String(pack.workflowMemory ?? ''),
         now: formatLocalNow(),
     });
@@ -1815,20 +1819,22 @@ async function resolveIntentFill(pack, userQuestion, baseUrl, env) {
 /**
  * `createForm` 的**取数阶段**（原 `commandCreateForm` 前半段，逐行搬过来，行为一字不改）。
  *
- * 抽出来的唯一目的：`createRequestDirect` 需要「未经压缩、未经落盘」的原始 payload —— 那条命令要把
- * `contextId` 与智能体算出的 `data` 直接喂给 `createRequest`，而 `commandCreateForm` 的输出可能
- * 因为超线只剩一句"结果已落盘"的提示，取不到这两个键。
+ * 抽出来的唯一目的：`createRequestDirect` 需要「未经压缩、未经落盘」的原始 payload ——
+ * `commandCreateForm` 的输出可能因为超线只剩一句"结果已落盘"的提示，取不到键。
+ *
+ * 2026-10-23 用户裁定：本函数**不再**调 `chatScene`（`createForm` 不再接 `userQuestion`）。
+ * 现在返回的就是纯取数结果：`fields` + `historyRequestData` + `systemFields` + 记忆，
+ * 由模型自己拼 `data` 后交给 `createRequest`。
  */
 async function prepareCreateFormPayload(args, env) {
     // 会话是**惰性**加载的（`ensureSession` 只在首次调用时填充）。本命令随后会并发发起多个请求，
     // 先在这里显式取一次，避免并发首调各自走一遍会话初始化。
-    // 顺带留住返回的上下文：智能填参要用它的 `baseUrl` 判「是不是真连了 OA」。
     //
     // 顺带计时：登录取凭据（小e 环境下是 `tokens.py` 换 eteamId + `teamsCheck` 换登录人这一整套）
     // 走的是 auth 层自己的 fetch，不经 `host.workflowRequest` ⇒ 天然落在 `apiDurations` 之外。
     // 这一段的耗时单独带出去（`authMs`），否则「总耗时 − 各接口」会凭空多出几百毫秒对不上账。
     const authStartedAt = Date.now();
-    const sessionCtx = await env.host.getSession();
+    await env.host.getSession();
     const authMs = Date.now() - authStartedAt;
     let target;
     let pack;
@@ -1875,24 +1881,16 @@ async function prepareCreateFormPayload(args, env) {
     // 该工作流的记忆：**一段 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 };
+    // ★ 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 用户裁定：返回值里固定带上**本命令自身的耗时**（毫秒）。
@@ -1901,27 +1899,25 @@ async function commandCreateForm(args, env) {
     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 { payload: fullPayload, authMs } = await prepareCreateFormPayload(args, timedEnv);
     // 取数阶段已全部结束 ⇒ 这里拿到的是完整的一份；它既是判线要预留的键，也是最终返回的值。
-    const apiDurations = summarizeApiSpans(spans);
-    // 判线的位数预留：`durationMs` / `apiDurations` / `authMs` 一定会有；`fillDurationMs` **只有走通
-    // chatScene 才有**，所以只在它会出现的这一轮才占位 —— 否则没走智能体时也白占十几个字符，边界上
-    // 会让本可内联的表单提前落盘。`apiDurations` 此刻已经求出，直接按真值占（不必用哨兵估）。
+    const { durations: apiDurations, slowest: apiSlowest } = summarizeApiSpans(spans);
+    // 判线的位数预留：`durationMs` / `apiDurations` / `apiSlowest` / `authMs` 一定会有。
+    // `apiDurations` 此刻已经求出，直接按真值占（不必用哨兵估）。
     const reserve = {
         durationMs: DURATION_RESERVE_SENTINEL,
         apiDurations,
+        apiSlowest,
         authMs: DURATION_RESERVE_SENTINEL,
     };
-    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` / `fillDurationMs` 的真值只能在压缩**之后**求
-        // （它们统计的正是这段时间），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘
+        // 判线要量"最终打出去的那份文本"，而 `durationMs` 的真值只能在压缩**之后**求
+        // （它统计的正是这段时间），故此处按位数用哨兵值先把它算进判线 —— 高估只让边界上的表单提前落盘
         // （安全方向）。
         reserve,
     });
@@ -1931,12 +1927,9 @@ async function commandCreateForm(args, env) {
         ...compacted,
         durationMs: Date.now() - startedAt,
         apiDurations,
+        apiSlowest,
         authMs,
     };
-    // `fillDurationMs`（生成表单参数的耗时）**只在真走通 chatScene 时出现**：失败降级走的是老口径，
-    // 返回面必须一个字都不多（对应需求「不符合预期则仍按原本逻辑执行和返回」）。
-    if (fill.durationMs !== undefined)
-        result.fillDurationMs = fill.durationMs;
     return workflowSuccess('workflow.createForm', result);
 }
 // ---------------------------------------------------------------------------
@@ -1966,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)
@@ -1995,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);
         }
@@ -2010,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) {
@@ -2024,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');
@@ -2087,7 +2101,7 @@ async function buildCreateFormData(workflowId, env) {
      * 小e 环境下两处都不跑（`createRequest` 同档也跳过字段联动与显示属性联动，由浏览器页面自己算）。
      * 非小e 环境行为不变。
      */
-    if (!hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.()) && 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);
@@ -2432,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)) {
@@ -2833,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();
@@ -2844,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 判为无值，整条值从保存体里消失，
@@ -3014,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();
@@ -3051,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;
@@ -4788,6 +4812,8 @@ function renderXiaoEFillFormMarkdown(params) {
  * （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` 统计不到，单独给一个数才能对上账。
  *
@@ -4798,11 +4824,70 @@ function stampCommandTimings(envelope, timing) {
     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 = summarizeApiSpans(timing.spans);
+    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` 的耗时外壳：建计时通道 + 量登录耗时 + 把三个耗时键并回结果。
  *
@@ -4913,8 +4998,13 @@ async function runCreateRequest(args, env, options = {}) {
     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();
@@ -4980,8 +5070,8 @@ async function runCreateRequest(args, env, options = {}) {
         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', {
@@ -5013,7 +5103,7 @@ async function runCreateRequest(args, env, options = {}) {
      *
      * **stdout 形态**（2026-10-21 用户裁定，**改口径**）：这一档同样**走 JSON 信封**，标签块放在
      * `data.finalMarkdown` 里 —— 与 `createRequestDirect` 统一，模型侧只有一条读法；`durationMs` /
-     * `apiDurations` / `authMs` 三个耗时键也因此在这一档可见。原来的「stdout 直接就是标签块、不套
+     * `apiDurations` / `apiSlowest` / `authMs` 四个耗时键也因此在这一档可见。原来的「stdout 直接就是标签块、不套
      * 信封」已作废（`shortcuts/workflow/index.ts` 的直出通道随之删除）。
      * 所以下面的 `message` 要明确告诉模型：从 `data.finalMarkdown` 取内容、原样作为本轮回复正文。
      *
@@ -5055,7 +5145,11 @@ async function runCreateRequest(args, env, options = {}) {
         // 同时给一份可直接原样粘贴的渲染档（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"），
@@ -5076,7 +5170,13 @@ async function runCreateRequest(args, env, options = {}) {
             ...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))];
@@ -5371,6 +5471,18 @@ function withApiTiming(host, spans) {
  *
  * 重叠判定用「区间扫描」而不是推断代码里的并发结构：只要两个请求在时间上真重叠就算一批，
  * 批量接口内部再起并发也照样能反映出来。
+ *
+ * ★ 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));
@@ -5392,88 +5504,109 @@ function summarizeApiSpans(spans) {
     }
     if (current.length)
         groups.push(current);
-    const out = {};
+    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))));
-        out[key] = (out[key] ?? 0) + cost;
-    }
-    return out;
+        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` —— **临时命令**：把「载入表单 + 智能填参」和「发起」串成一步。
- *
- * 等价于「先跑 `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` 取内容原样回复。
+ * `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` 自己也超线时不再裁**（宁大不丢）—— 它是唯一不可省的，砍了这条命令就没有意义。
  *
  * ## 耗时
- * - `data.durationMs` = 命令总耗时；
- * - `data.apiDurations` = 每个接口（并行批次合并）的耗时；
- * - `data.authMs` = 登录取凭据（首次会话解析）的耗时 —— 这段走 auth 层自己的 fetch，不经
- *   `host.workflowRequest`，`apiDurations` 统计不到，单独给一个数才能对上账
- *   （`durationMs` ≈ `apiDurations` 合计 + `authMs` + 本地解析/渲染的零头）。
- * 三者都只在 `data` 是普通对象时挂；本命令与 `createRequest` 用的是**同一个** `stampCommandTimings`，
- * 差别只在时间区间（这里从命令入口起算、覆盖表单载入那一段）。
+ * 与 `createForm` 完全同口径，全部收在 `timing` 一个桶里：`durationMs`（整条命令）/
+ * `apiDurations`（按并行批合并的接口耗时）/ `apiSlowest`（每个真并行批的最慢项，`items` 里带批内
+ * 每个接口各自的耗时）/
+ * `authMs`（会话解析）。本命令不会出现 `fillDurationMs` —— 那一项统计的是 `chatScene`，不再有这一段。
  */
 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);
+    // 取数段本身已经不碰 `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', '表单载入未产出可用句柄，本次未发起任何写入，请重试');
-    }
-    // ★ 智能体没给出可用 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 });
+        // `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();
@@ -6527,7 +6660,7 @@ const workflowCreateForm = {
     resource: 'workflow',
     method: 'createForm',
     action: 'workflow.createForm',
-    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好。传了 userQuestion 时额外调智能体把意图算成 data 参数（此时不返回 historyRequestData / systemFields）',
+    summary: '按工作流参数解析可发起的工作流并载入发起表单：loadBase/loadFrame/loadMinor/formLayout 合并为 runtime 与 frame，产出 context 句柄 + 字段清单 + fileUploadParams + 该工作流的发起偏好。只取数、不填参（不再调智能体）：模型据此自己拼 data 后交给 createRequest',
     capability: 'create',
     risk: 'read',
     requiresConfirmation: false,
@@ -6537,14 +6670,6 @@ const workflowCreateForm = {
             items: { type: 'string' },
             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),
 };
@@ -6566,8 +6691,8 @@ 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'] }),
@@ -6578,27 +6703,17 @@ const workflowCreateRequestDirect = {
     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,
+    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 完全一致（含澄清规则）',
         },
-        userQuestion: {
-            type: 'string',
-            description: '用户的填单意图（一句话概括，可多轮汇总）。命令会把它交给智能体算出要填的字段值后直接发起；为空或智能体没给出可用结果时，按"一个字段都没填"继续发起',
-        },
-        action: {
-            type: 'string',
-            enum: ['draft', 'submit'],
-            description: 'draft=仅保存草稿；submit=提交审批（必填缺失时不写库、一次性回报缺失项）',
-        },
-        verificationConfirmed: { type: 'boolean', description: '节点字段校验需用户确认时显式确认继续提交' },
-    }, { required: ['workflow', 'userQuestion', 'action'] }),
+    }, { required: ['workflow'] }),
     handler: (args, env) => commandCreateRequestDirect(args, env),
 };
 const workflowEditLoad = {