weaver-work-cli 0.1.24 → 0.1.26

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

@@ -1478,6 +1478,25 @@ async function enforceSearchStdoutBudget(result, env, fileName) {
     };
 }
 // ---------------------------------------------------------------------------
+// 命令耗时（`durationMs`）
+// ---------------------------------------------------------------------------
+/**
+ * 给 envelope 的 `data` 顶层补一个 `durationMs`（整数毫秒）。
+ *
+ * 口径与 `createForm` 的 `durationMs` **完全一致**（2026-10-19 用户裁定把这条命令也纳入）：
+ * 起点 = 命令 handler 入口（含会话解析、取数、落盘等全部动作），终点 = 返回之前；
+ * 放在 `data` 顶层而不是信封 `meta`，这样「超线落盘」那一档 `data` 只剩一句提示时耗时依然在。
+ *
+ * 只在 `workflow.search` / `workflow.memoryPrompt` 两条命令上接线（用户明确「其他命令暂时不动」）。
+ * `data` 不是普通对象（数组/字符串/空）时原样返回，绝不因为加耗时而改变返回形态。
+ */
+function stampDurationMs(envelope, startedAt) {
+    const data = envelope?.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        return envelope;
+    return { ...envelope, data: { ...data, durationMs: Date.now() - startedAt } };
+}
+// ---------------------------------------------------------------------------
 // 序号定位（查询类写索引；查看类读索引）
 // ---------------------------------------------------------------------------
 async function saveListIndex(env, normalized) {
@@ -1566,6 +1585,8 @@ const workflowSearch = {
         queryJson: { type: 'object', description: '已生成的完整查询 JSON（跳过 build-query）' },
     }),
     handler: async (args, env) => {
+        // 耗时起点：整条命令的入口（含 plan 门禁的版本探测、取数、落盘）。
+        const startedAt = Date.now();
         const plan = args.planJson;
         if (plan && typeof plan === 'object') {
             // plan 批量编排仅智能分组模式支持（来源：Python cmd_workflow_search_plan 首行的
@@ -1578,7 +1599,7 @@ const workflowSearch = {
                 throw workflowValidationError('plan_requires_smart_mode', `plan 批量编排模式仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请改用单条 workflow.search`, { retryAllowed: false });
             }
             // 顶层 pageSize 即 plan 的展示窗口 page_cap（来源：Python cmd_workflow_search_plan 的 page_cap）
-            return executePlanSearch(env, plan, asInt(args.pageSize) ?? 10);
+            return stampDurationMs(await executePlanSearch(env, plan, asInt(args.pageSize) ?? 10), startedAt);
         }
         const category = (asString(args.category) || 'todo');
         const searchMode = await resolveSearchMode(env);
@@ -1588,7 +1609,7 @@ const workflowSearch = {
         // grouping_active 分支）：未显式指定子分类、非 total-only、非批量取数时按「待处理/超时/紧急」
         // 分组取数并输出分组统计。smart 模式不做 CLI 侧分组（分组由模型按 countDetails 规划）。
         if (searchMode === 'legacy' && category === 'todo' && !batchType && !totalOnly && !hasExplicitTab(args)) {
-            return executeLegacyGroupedTodoSearch(env, args);
+            return stampDurationMs(await executeLegacyGroupedTodoSearch(env, args), startedAt);
         }
         const { query, tabid } = await buildSearchQuery(env, { ...args, searchMode }, 'list');
         const prefix = ENDPOINT_PREFIX[category];
@@ -1652,13 +1673,13 @@ const workflowSearch = {
             }
         }
         if (totalOnly) {
-            return workflowSuccess('workflow.search', {
+            return stampDurationMs(workflowSuccess('workflow.search', {
                 type: 'workflowSearch',
                 category,
                 categoryName: CATEGORY_NAMES[category],
                 total,
                 finalMarkdown: buildSearchFinalMarkdown(null, probes, total, category, true, searchMode === 'smart', waitReadTotal),
-            });
+            }), startedAt);
         }
         // 卡片摘要行只在 **legacy（低版本模式）** 生成——契约见 references/workflow-query.md
         // 「执行模式与返回形态」的「卡片摘要行」一行（低版本=标题/摘要/辅助三行；智能分组=标题/辅助
@@ -1674,7 +1695,7 @@ const workflowSearch = {
             await enrichWorkflowCardSummaries(env, normalized, asInt(args.pageSize) ?? normalized.pageSize);
         }
         const index = await saveListIndex(env, normalized);
-        return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
+        return stampDurationMs(workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
             type: 'workflowSearch',
             category,
             categoryName: CATEGORY_NAMES[category],
@@ -1688,7 +1709,7 @@ const workflowSearch = {
             finalMarkdown: buildSearchFinalMarkdown(normalized, probes, total, category, false, searchMode === 'smart', waitReadTotal, withCardSummaries),
             queryId: index.queryId,
             sessionMap: { queryId: index.queryId, itemCount: normalized.items.length },
-        }, env, { json: 'last_search.json', md: 'last_search.md' }));
+        }, env, { json: 'last_search.json', md: 'last_search.md' })), startedAt);
     },
 };
 // ---------------------------------------------------------------------------
@@ -4815,6 +4836,8 @@ const workflowMemoryPrompt = {
         dynamicContext: { type: 'object', description: '动态上下文参数（可选，合并进 dynamicContextParams）' },
     }),
     handler: async (args, env) => {
+        // 耗时起点：整条命令的入口（含记忆接口那一趟与会话解析）。
+        const startedAt = Date.now();
         // 记忆接口契约（来源：Python memory_chat_params）：
         //   { appid: <记忆应用 ID>, dynamicContextParams: { workflowId?, ...额外上下文 } }
         // 缺 appid 时接口判为无效应用，直接返回空 promptText（available=false）——
@@ -4897,6 +4920,8 @@ const workflowMemoryPrompt = {
         if (!hasOaContext) {
             result.oaContextMissingReason = '当前 E10 会话中未包含 OA 版本与用户身份信息。请先运行 weaver-work-cli auth status 确认登录态；若会话确已失效，请用 weaver-work-cli auth login --base-url <域名> --agent_type <当前智能体名称> 重新登录后重试。';
         }
+        // 命令耗时（毫秒）：与 createForm / workflow.search 同口径，`data` 顶层。
+        result.durationMs = Date.now() - startedAt;
         return workflowSuccess('workflow.memoryPrompt', result, {
             oaContextMissing: !hasOaContext,
         });
@@ -4961,6 +4986,13 @@ function isEmptyRawFieldValue(value) {
  *
  * 与 `detailFormFieldValue` 同契约、同候选顺序，唯一区别是**不提前串化**——后者服务详情面板
  * （只需要可读文本），前者服务历史参考值（还需要 `id` 才能拼出 `名称(id)`）。两处必须同步修改。
+ *
+ * ★ 2026-10-14 补齐 `dataText` 候选（此前只存在于 `detailFormFieldValue`，两边口径**并不一致**）：
+ * `TextArea` 类字段（真机 `报销事由`）的值在 detail 响应里是 `dataText: {content/richContent/…}`，
+ * 只有详情面板分支认得它 ⇒ 历史参考值恒缺这一类字段（真机实证：同一条历史流程，
+ * 详情面板解出 50 个字段、历史取值只有 49 个，差的正好是唯一的必填 `TextArea` 字段
+ * `报销事由`，其值 `2026-08…`）。这里返回**已抽出的展示文本**（与详情面板同口径），
+ * 调用方的 `formatHistoryFieldValue` 仍会按字段类型二次格式化。
  */
 function detailFormFieldRawValue(obj, formField) {
     const dataKey = pickText(formField, 'dataKey', 'fieldKey', 'key');
@@ -4978,6 +5010,12 @@ function detailFormFieldRawValue(obj, formField) {
     }
     if (Array.isArray(obj?.dataOptions) && obj.dataOptions.length)
         return obj.dataOptions;
+    const dataText = obj?.dataText;
+    if (dataText && typeof dataText === 'object') {
+        const text = stringifyDetailDataText(dataText);
+        if (text)
+            return text;
+    }
     for (const key of ['showValue', 'displayValue', 'fieldValue', 'value', 'content', 'text']) {
         if (obj && typeof obj === 'object' && key in obj) {
             const value = obj[key];
@@ -5096,32 +5134,17 @@ function formatHistoryFieldValue(raw, field) {
     return stringifyDetailValue(raw);
 }
 /**
- * 取「历史流程可参考字段值」。返回 `null` 表示没有可参考的历史数据。
+ * 历史取数的**前半段**：只发那一次列表请求。
  *
- * - `fields`：当前表单布局里的字段清单（`context.fields`，用来判断字段是不是浏览按钮/选项类，
- *   并在 `allFormFields` 档收口缓存范围——只有本表单的字段 id 会被保留）
- * - `targets`：本次要取值的字段（`{id,name}` 或 `missingFields` 同形；`systemField` 项会被忽略）
- * - `options.allFormFields`：见 `HistoryRequestDataOptions`
+ * 与 `buildHistoryRequestData` 拆开的原因（P2 提速，2026-10-13）：这一步**只依赖 `workflowId`**，
+ * 不需要任何表单字段 ⇒ 可以和 `loadBaseParam` / `loadFrameParam` / `loadMinorInfo` / `getFormLayout`
+ * 一起**并发发起**，不再排在这些载入之后的串行尾巴上（真机该请求约 1–2 s，落在关键路径上纯亏）。
  *
- * 只保留**至少命中 1 个可参考字段值**的历史流程；系统字段（流程标题/紧急程度等）不参与。
+ * 失败口径与整体一致：一律降级为 `null`（`rethrowAuthOrNetworkError` 仍会把认证/网络类错误抛出去，
+ * 由调用方决定；调用方若走"预取 + 复用"的形态，必须在预取处 `.catch(() => null)` 兜住，
+ * 避免出现无人 `await` 的未处理拒绝——真正需要暴露的认证错误由同批的载入请求抛出，不会因此被吞掉）。
  */
-export async function buildHistoryRequestData(env, fields, targets, options = {}) {
-    const targetList = toArray(targets)
-        .filter((item) => !item?.systemField && String(item?.id ?? '').trim())
-        .map((item) => ({ id: String(item.id).trim(), name: String(item.name ?? item.id) }));
-    // 普通档必须真的有字段要取；缓存档允许 targets 为空（表单本身没有静态必填时，
-    // 缓存仍要建——条件必填是在 createRequest 阶段才现身的，那时已经没有联网取数的机会了）。
-    if (!targetList.length && !options.allFormFields)
-        return null;
-    const fieldMeta = new Map();
-    for (const field of toArray(fields))
-        fieldMeta.set(String(field?.id ?? ''), field);
-    // 取值顺序 = 「本表单布局顺序」（缓存档）或 targets 顺序（普通档）。
-    // 缓存档用布局顺序是为了结果稳定可 diff；但只保留本表单的字段 id，避免把别张表单的字段带进来。
-    const orderedIds = options.allFormFields
-        ? [...fieldMeta.keys()]
-        : targetList.map((t) => t.id);
-    const nameOf = new Map(targetList.map((t) => [t.id, t.name]));
+export async function fetchHistoryListSnapshot(env, options = {}) {
     try {
         const now = new Date();
         const start = new Date(now.getTime() - HISTORY_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
@@ -5160,6 +5183,122 @@ export async function buildHistoryRequestData(env, fields, targets, options = {}
         const requestIds = items.map((item) => String(item?.requestId ?? '').trim()).filter(Boolean);
         if (!requestIds.length)
             return null;
+        return { items, requestIds };
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return null;
+    }
+}
+/**
+ * 「多候选里按用户近一年的发起记录消歧」——`createForm` 澄清前的最后一次尝试。
+ *
+ * 场景（2026-10-20 用户裁定）：`workflow` 只给了名称、**多命中又没有全名精确匹配**，本来要返回
+ * 多候选澄清。但用户往往只发起过其中之一 ⇒ 用「我发起的」**工作流树**把候选里他真发起过的捞出来：
+ * 只剩一个就直接用它，不必再问一遍；否则照旧澄清。
+ *
+ * 请求 = `getMineListData` 的 body **去掉分页**（`customDisplayPage`），外加一个 `workflowid`
+ * 条件把范围**限定在待澄清候选上**（"涉及这次要澄清的那些工作流的流程"）。`workflowid` 属
+ * 浏览按钮类条件，**只认 `browserDatas`**——`multiContent` 会被服务端静默忽略（2026-09-29 实测）。
+ *
+ * 判据（用户逐字给定）：`data.data` 恰一个根、该根 `children` 恰一个子 ⇒ 唯一。子节点 id 形如
+ * `wf_<workflowId>`，去掉 `wf_` 即工作流 ID。
+ *
+ * 返回 `null` 的**所有**情形（候选不足 2 个 / 无数据 / 多个根 / 单个根多个子 / 命中项不在候选内 /
+ * 接口失败或返回异常）都由调用方**回落原澄清**：本函数只回答"能不能确定"，绝不上抛错误
+ * ——兜底查询的失败不能顶掉用户本来要看到的那条澄清文案。
+ */
+export async function pickUniqueMineWorkflow(candidates, env) {
+    const candidateIds = [];
+    const nameById = new Map();
+    for (const item of toArray(candidates)) {
+        const id = String(item?.id ?? '').trim();
+        if (!id || nameById.has(id))
+            continue;
+        candidateIds.push(id);
+        nameById.set(id, String(item?.name ?? ''));
+    }
+    // 只有一个候选时上游已经直接采用了，不会走到这里；0 个也没得消歧。
+    if (candidateIds.length < 2)
+        return null;
+    try {
+        const now = new Date();
+        const start = new Date(now.getTime() - HISTORY_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.MINE_TREE,
+            operation: 'workflow.createForm.mineTree',
+            body: {
+                params: { tabid: DEFAULT_TABID.mine, dimension: 'mine', flowSpareType: 1, outType: 0 },
+                searchParams: {
+                    formDatas: {
+                        // 与历史取数同一口径：非草稿（未结束 + 已结束）。选项类条件必须是 `multiContent`。
+                        flowstatus: flowStatusCondition('notFinish,finish')?.condition ?? [],
+                        createdatetime: [{
+                                dateContent: [formatLocalDate(start), formatLocalDate(now)],
+                                term: 'like',
+                            }],
+                        workflowid: [{
+                                term: 'in',
+                                browserDatas: candidateIds.map((id) => ({ id, name: nameById.get(id) ?? '' })),
+                            }],
+                    },
+                    type: 'and',
+                    initSearch: false,
+                },
+            },
+        });
+        const body = (response && typeof response === 'object' ? response : {});
+        if (body.fail === true || body.status === false)
+            return null;
+        const roots = toArray(body.data?.data);
+        if (roots.length !== 1)
+            return null;
+        const children = toArray(roots[0]?.children);
+        if (children.length !== 1)
+            return null;
+        const rawId = String(children[0]?.id ?? '').trim();
+        const id = rawId.startsWith('wf_') ? rawId.slice(3) : rawId;
+        // 双保险：服务端若没认 `workflowid` 条件、回了别的流程，这里必须挡掉（宁可澄清也不猜）。
+        if (!id || !nameById.has(id))
+            return null;
+        const title = String(children[0]?.title ?? '').trim();
+        return { id, name: title || (nameById.get(id) ?? '') };
+    }
+    catch {
+        // 认证/网络/格式错误一律按"没能确定"处理 —— 澄清才是用户能继续操作的出口。
+        return null;
+    }
+}
+export async function buildHistoryRequestData(env, fields, targets, options = {}, 
+/**
+ * 已提前发起的列表请求（见 `fetchHistoryListSnapshot`）。传入即直接复用，不再重复发请求；
+ * 传 `null` / 不传时退回"本函数内自己发列表"的老口径。
+ */
+prefetchedList) {
+    const targetList = toArray(targets)
+        .filter((item) => !item?.systemField && String(item?.id ?? '').trim())
+        .map((item) => ({ id: String(item.id).trim(), name: String(item.name ?? item.id) }));
+    // 普通档必须真的有字段要取；缓存档允许 targets 为空（表单本身没有静态必填时，
+    // 缓存仍要建——条件必填是在 createRequest 阶段才现身的，那时已经没有联网取数的机会了）。
+    if (!targetList.length && !options.allFormFields)
+        return null;
+    const fieldMeta = new Map();
+    for (const field of toArray(fields))
+        fieldMeta.set(String(field?.id ?? ''), field);
+    // 取值顺序 = 「本表单布局顺序」（缓存档）或 targets 顺序（普通档）。
+    // 缓存档用布局顺序是为了结果稳定可 diff；但只保留本表单的字段 id，避免把别张表单的字段带进来。
+    const orderedIds = options.allFormFields
+        ? [...fieldMeta.keys()]
+        : targetList.map((t) => t.id);
+    try {
+        const listed = prefetchedList
+            ? await prefetchedList
+            : await fetchHistoryListSnapshot(env, options);
+        if (!listed)
+            return null;
+        const items = listed.items;
+        const requestIds = listed.requestIds;
         const session = await env.host.getSession();
         const details = await Promise.all(requestIds.map(async (requestId) => {
             const payload = {
@@ -5184,30 +5323,29 @@ export async function buildHistoryRequestData(env, fields, targets, options = {}
             const data = details[index] || {};
             const rawById = new Map();
             collectHistoryFieldRawValues(data, rawById);
-            const fieldValues = [];
+            // 键序 = `orderedIds`（本表单布局顺序）的插入顺序；同一字段只留**首个**取到值的结果。
+            const fieldValues = {};
             for (const fieldId of orderedIds) {
                 const raw = rawById.get(fieldId);
                 if (raw === undefined || raw === null)
                     continue;
+                if (Object.prototype.hasOwnProperty.call(fieldValues, fieldId))
+                    continue;
                 const value = formatHistoryFieldValue(raw, fieldMeta.get(fieldId));
                 // 附件类返回的是对象 ⇒ 不能再用 `String(value).trim()` 判空（那会得到 "[object Object]"）。
                 if (isEmptyRawFieldValue(value))
                     continue;
-                fieldValues.push({
-                    fieldId,
-                    fieldName: nameOf.get(fieldId) || String(fieldMeta.get(fieldId)?.name ?? fieldId),
-                    value,
-                });
+                fieldValues[fieldId] = value;
             }
-            if (!fieldValues.length)
+            if (!Object.keys(fieldValues).length)
                 continue;
             const base = data.workflowBaseInfo && typeof data.workflowBaseInfo === 'object' ? data.workflowBaseInfo : {};
             const listedItem = items[index] || {};
             result.push({
-                requestId: requestIds[index],
                 requestName: pickText(base, 'requestName', 'requestNameTitle')
                     || String(listedItem.flowName ?? ''),
-                createTime: pickText(base, 'createDateTime', 'createTime')
+                requestId: requestIds[index],
+                createdatetime: pickText(base, 'createDateTime', 'createTime')
                     || String(listedItem.createdAt ?? ''),
                 fieldValues,
             });
@@ -5241,9 +5379,16 @@ export function filterHistoryRequestData(records, fieldIds) {
     for (const record of toArray(records)) {
         if (!record || typeof record !== 'object')
             continue;
-        const fieldValues = toArray(record.fieldValues)
-            .filter((value) => value && wanted.has(String(value.fieldId ?? '')));
-        if (!fieldValues.length)
+        const source = record.fieldValues;
+        if (!source || typeof source !== 'object' || Array.isArray(source))
+            continue;
+        // 保留原键序，只留下本次要看的字段（口径见函数注释）。
+        const fieldValues = {};
+        for (const fieldId of Object.keys(source)) {
+            if (wanted.has(fieldId))
+                fieldValues[fieldId] = source[fieldId];
+        }
+        if (!Object.keys(fieldValues).length)
             continue;
         result.push({ ...record, fieldValues });
     }

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

@@ -1,4 +1,5 @@
 import { WorkflowCliError, workflowValidationError } from '../errors.js';
+import { stringifyForStdout } from '../../../core/output.js';
 /**
  * 模型输入中永远不允许出现的键。
  *
@@ -212,3 +213,27 @@ export function stdoutBytesOf(value) {
         return 0;
     }
 }
+/**
+ * 宿主**实际看到**的 stdout 字符数 —— 与 `Output.write` 真正打出去的那份文本**同源**
+ * （同一条 `stringifyForStdout` + 同一套紧凑路径），而不是"美化 JSON 长度的近似值"。
+ *
+ * ★ 判线必须与最终输出同源。2026-10-15 之前量的是 `JSON.stringify(value, null, 2).length`（纯美化），
+ * 而紧凑路径会把 `fields` / `historyRequestData` / `systemFields` 的缩进空白整段压掉 —— 实测
+ * `createForm` 整份小约 **30%**（`hugeLayout(120)` 桩：23,522 → 16,613 字符），那份桩因此从
+ * 「超线落盘」翻成「内联返回」。两份数一旦脱钩，判线就**系统性高估**：本可内联的表单被判落盘。
+ * 而宿主侧的线（`terminal_tool.py` 的 `MAX_OUTPUT_LEN = 20000`）量的是**最终输出文本**的 `len()`，
+ * 它并不关心美化不美化。
+ *
+ * `compactPaths` 从**信封根**算起（如 `data.fields`）；不传即按无紧凑路径量（等价于纯美化）。
+ * 其余命令仍用 `stdoutBytesOf()` 的**字节**口径 —— 两个口径对纯 ASCII 一致、对中文差 3 倍
+ * （1 字符 / 3 字节），**用哪个必须跟着阈值走**，不可混用。
+ */
+export function stdoutCharsOf(value, compactPaths) {
+    try {
+        const text = stringifyForStdout(value, compactPaths);
+        return typeof text === 'string' ? text.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/shortcuts/workflow/operations/sign-input.js

@@ -0,0 +1,106 @@
+import { AJAX_QUERY, FORM_ENDPOINTS } from '../endpoints.js';
+/** 接口没给出可用值时的兜底 —— 与真机默认值一致（`微软雅黑/Microsoft YaHei`、`18/18px`）。 */
+const DEFAULT_FONT_FAMILY = 'Microsoft YaHei';
+const DEFAULT_FONT_SIZE = '18px';
+const DEFAULT_FONT_ID = 'wea_rich_text_default_font';
+/**
+ * `defaultFontFamily` / `defaultFontSize` 都是「中文名/实际值」的双段形态
+ * （`微软雅黑/Microsoft YaHei`、`18/18px`）。CSS 要的是斜杠**后面**那段；没有斜杠就整段用。
+ */
+function cssValue(raw, fallback) {
+    const text = String(raw ?? '').trim();
+    if (!text)
+        return fallback;
+    const segments = text.split('/').map((item) => item.trim()).filter(Boolean);
+    const value = segments.length ? segments[segments.length - 1] : '';
+    if (!value)
+        return fallback;
+    return value;
+}
+/** 字号只给数字（`18`）时补单位 —— 否则拼出来的 `font-size:18` 是无效 CSS，浏览器会整条丢弃。 */
+function cssFontSize(raw) {
+    const value = cssValue(raw, DEFAULT_FONT_SIZE);
+    return /^\d+(\.\d+)?$/u.test(value) ? `${value}px` : value;
+}
+/**
+ * 取签字意见的默认样式。**失败一律返回 `null`**（调用方据此退回原行为），绝不阻断提交 ——
+ * 这只是给意见加样式，不能因为样式接口挂了就让整条流程发不出去。
+ */
+export async function loadSignInputCfg(env, target) {
+    const workflowId = String(target.workflowId ?? '').trim();
+    const requestId = String(target.requestId ?? '').trim();
+    // 发起流程用 `workflowId` + `isCreate:1`；提交已有流程用 `requestId` + `isCreate:0`。
+    const isCreate = workflowId && !requestId;
+    if (!isCreate && !requestId)
+        return null;
+    const body = isCreate
+        ? { isRemark: '', workflowId, isCreate: 1 }
+        : {
+            isRemark: 0,
+            operResultType: 'SUCCESS_RELOAD_CURRENT_PAGE',
+            userSpecifiedNodeId: '0',
+            autoMaxDisplay: '0',
+            isCreate: 0,
+            requestId,
+        };
+    try {
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: FORM_ENDPOINTS.signInputInfo,
+            // 与同族 `flowPage/*` 接口（loadBaseParam / loadFrameParam / loadMinorInfo）取同一份公共 query。
+            query: AJAX_QUERY,
+            body,
+            operation: isCreate ? 'workflow.createRequest' : 'workflow.operateApply',
+        });
+        const cfg = response?.data?.signInputCfg;
+        if (!cfg || typeof cfg !== 'object')
+            return null;
+        const raw = cfg.plainTextSignInput;
+        return {
+            plainText: raw === true || String(raw ?? '').toLowerCase() === 'true',
+            fontFamily: cssValue(cfg.defaultFontFamily, DEFAULT_FONT_FAMILY),
+            fontSize: cssFontSize(cfg.defaultFontSize),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function escapeText(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/**
+ * 把签字意见包成服务端能正确渲染的形态。
+ *
+ * - 空内容 ⇒ `_weaverMte_`（与历史一致，表示"没有意见"）；
+ * - 已带 `_weaverMte_` 前缀（模型自己给了富文本）⇒ 原样，不重复嵌套；
+ * - `cfg` 取不到 ⇒ 退回历史行为 `_weaverMte_<p>内容</p>`（不知道协商格式就不猜）；
+ * - `plainTextSignInput` 为真 ⇒ `<span id=... style=...>内容</span>`；
+ * - 否则 ⇒ `_weaverMte_<div id=... style=...><p>内容</p></div>`。
+ */
+export function wrapSignRemark(raw, cfg) {
+    const text = String(raw ?? '').trim();
+    if (!text)
+        return '_weaverMte_';
+    if (text.startsWith('_weaverMte_'))
+        return text;
+    if (!cfg)
+        return `_weaverMte_<p>${escapeText(text)}</p>`;
+    const style = `font-family:${cfg.fontFamily};font-size:${cfg.fontSize};`;
+    const escaped = escapeText(text);
+    if (cfg.plainText) {
+        return `<span id="${DEFAULT_FONT_ID}" style="${style}">${escaped}</span>`;
+    }
+    return `_weaverMte_<div id="${DEFAULT_FONT_ID}" style="${style}"><p>${escaped}</p></div>`;
+}
+/**
+ * 提交侧的入口：**只在真有意见、且还没带富文本前缀时**才去问样式接口。
+ *
+ * 没有意见 / 已经是 `_weaverMte_` 富文本 ⇒ 一次请求都不发（这两档包与不包结果一样）。
+ */
+export async function resolveSignRemark(env, raw, target) {
+    const text = String(raw ?? '').trim();
+    if (!text || text.startsWith('_weaverMte_'))
+        return wrapSignRemark(raw, null);
+    return wrapSignRemark(text, await loadSignInputCfg(env, target));
+}

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

@@ -5,6 +5,7 @@ import { defaultTabIdOf, rethrowAuthOrNetworkError, runWorkflowSearch } from './
 import { CONTINUATION_INPUT, SCHEMA_CATEGORY, SCHEMA_CONFIRM, SCHEMA_INDEX, SCHEMA_REQUEST_ID, schemaOf, workflowSuccess, } from './types.js';
 import { asInt, asString, asStringArray, compact, responseData, detailDataOf, toArray, resolveMemoryAppId } from './shared.js';
 import { WORKFLOW_ENDPOINTS } from '../endpoints.js';
+import { resolveSignRemark } from './sign-input.js';
 import { findIndexedItem, loadSearchIndex, } from '../state.js';
 // ===========================================================================
 // 工作流写操作（operate / share / batch / memory）
@@ -1013,7 +1014,14 @@ const workflowOperateApply = {
                         verification,
                     });
                 }
-                const payload = await withUserId(env, { requestId, remark });
+                // 提交前先按租户配置把签字意见包成带默认字体/字号的形态（已有流程 ⇒ `isCreate:0` + `requestId`）。
+                // 取不到样式时 `resolveSignRemark` 内部已退回原形态，不会阻断提交。
+                // **没意见就原样传空串**：这条命令历史上空意见就是 `''`（不像发起侧用 `_weaverMte_` 占位），
+                // 改成占位符会改变提交请求体，没有必要。
+                const signRemark = String(remark ?? '').trim()
+                    ? await resolveSignRemark(env, remark, { requestId })
+                    : remark;
+                const payload = await withUserId(env, { requestId, remark: signRemark });
                 if (nodeId)
                     payload.userCurrentNodeId = nodeId;
                 if (prepared.requestName)

package/dist/shortcuts/workflow/stdout-compact.js

@@ -0,0 +1,41 @@
+/**
+ * 「只去缩进、不动内容」的 stdout 路径（按 operation 声明；路径从**信封根**算起）。
+ *
+ * 依据（实测）：
+ * - `historyRequestData` 独占 `createForm` 输出的 60%（真机 13,017 B / 21,620 B），其中近 1/4 是缩进
+ *   空白 —— 压成单行后 9,835 B、整份 18,438 B（2026-10-14 用户裁定纳入）。
+ * - `fields`（2026-10-15 用户裁定纳入）是"每个字段占 4 行"的数组，缩进空白占它自己 **24%~31%**
+ *   —— 实测平铺字段的桩（仅 `id`/`name`/`componentKey`/`browserType`）20,642 → 15,601 字符（省 24%）；
+ *   带 `options` / `fileUploadParams` 的嵌套字段层级更深，可到约 31%。它通常占整份输出的 **88% 上下**。
+ * - `systemFields`（同日用户裁定纳入）是"层级深、内容短"的小对象：`permissions` 是一层
+ *   `{系统字段: {isview/isedit/ismandatory}}`、`levelOptions` / `secLevelOptions` 是选项数组，
+ *   缩进空白占它自己约 **29%**（259 → 183 字符），而它每次都要下发。
+ *
+ * 三个键合计的效果（`hugeLayout(120)` 桩实测）：整份 **23,522 → 16,613 字符（省 29.4%）**
+ * —— 该桩因此从「超线落盘」翻成「内联返回」。字段里嵌套对象越多、`fields` 占整份比例越高，省得越多。
+ *
+ * 三个键都是"逐条长、层级深"的典型：读它们要的是「哪个字段 / 什么值」，每层两个空格的缩进没有
+ * 任何信息量。**内容一字不改**：输出仍是合法 JSON，`parse` 出来与全缩进版完全一致（只是空白不同），
+ * 结构也保持数组原样、不会退化成"需要再 parse 一次的字符串"，消费端零改动
+ * （实现见 `core/output.ts` 的 `stringifyForStdout`）。
+ *
+ * **为什么独立成模块**（而不是留在 `shortcuts/workflow/index.ts`）：`operations/form.ts` 的判线也要用
+ * 同一份路径 —— 它量的必须是**这条命令最终打出去的那份文本**（见 `finalStdoutChars`）。常量若留在
+ * `index.ts`，`form.ts` 反向 import 就会与 `index → operations → form` 形成循环依赖；常量放这里、
+ * 两边都正向引用，依赖图仍是单向的。
+ */
+export const COMPACT_STDOUT_PATHS = {
+    // `data.data`（智能填参算出的字段值）与 `fields` 同构：键是字段 id、层级深，压掉缩进省得可观。
+    // 它与 `historyRequestData` / `systemFields` **互斥出现**（智能体成功时后两者已被删），
+    // 三个都登记在这里不会互相干扰。
+    'workflow.createForm': [
+        'data.fields',
+        'data.historyRequestData',
+        'data.systemFields',
+        'data.data',
+    ],
+};
+/** 该 operation 的紧凑路径（不声明 = 维持全量缩进）。导出让用例锁住接线。 */
+export function compactStdoutPaths(operation) {
+    return COMPACT_STDOUT_PATHS[operation];
+}

package/docs/archive-oa.md

@@ -0,0 +1,79 @@
+# 泛微商务合同档案查询 CLI
+
+来源 Skill：`weaver-e10-archive-oa`。本模块把接口文档中可安全自动化的能力封装为 `weaver-work-cli archive-oa` 命令，供 AI Agent 通过结构化 JSON 调用。
+
+源码位于 `src/shortcuts/archive-oa`。命令注册、`operation manifest` 和业务执行逻辑分离：manifest 由 `operations/registry.ts` 汇总各 operation 定义生成，具体执行逻辑在 `src/shortcuts/archive-oa/operations` 中按业务分组维护（档案定位、合同查询、借阅车、发起借阅）。
+
+面向 Agent 的说明位于 `skills/weaver-e10-archive-oa`。入口 `SKILL.md` 只负责共享规则和 reference 路由；具体细节拆在 `skills/weaver-e10-archive-oa/references/`，与飞书 CLI 的业务 Skill 组织方式保持一致。
+
+## 公共前置
+
+先通过 E10 鉴权模块登录：
+
+```text
+weaver-work-cli auth login --base-url "https://weapp.xxx.cn" --agent_type "<当前智能体名称>"
+weaver-work-cli auth status --no-check
+```
+
+每个业务请求由 CLI 托管：
+
+1. 读取当前 `weaver-work-cli auth` Profile 的 E10 会话。
+2. 请求只允许 `/api/`（ebuilder 业务接口）与 `/openserver/`（E10 开放服务）路径，由 CLI 携带 E10 Cookie/ETEAMSID 与必要的业务头。
+3. 响应按以下规则判定业务成功：ebuilder 列表/ESB 看 `code=200` 与 `status=true`；ebuilder 自定义接口看 `datajson.status`。
+
+Agent 不得在业务 JSON 中传 Cookie、ETEAMSID、Token 或内部控制字段。
+
+## Agent 入口
+
+优先使用 `archive-oa run <operation>`：
+
+Windows PowerShell：
+
+```powershell
+weaver-work-cli archive-oa schema
+weaver-work-cli --json archive-oa run archive-oa.contract.list --input-json '{"pageNo":1}'
+```
+
+macOS/Linux（bash/zsh）：
+
+```bash
+weaver-work-cli archive-oa schema
+weaver-work-cli --json archive-oa run archive-oa.contract.list --input-json '{"pageNo":1}'
+```
+
+复杂或多行 JSON：先写成 UTF-8 文件，再用 `--input <path>`（`--input -` 读 stdin）。不要存在 `~/.tmp` 之类的路径假设；Windows 用 `$env:TEMP`，macOS/Linux 用临时目录。
+
+## operation 划分
+
+| 分组 | operation |
+| --- | --- |
+| 档案定位 | `archive-oa.archive.locate` |
+| 泛微合同 | `archive-oa.contract.list`、`archive-oa.contract.fields` |
+| 泛微借阅车 | `archive-oa.borrow-car.list`、`archive-oa.borrow-car.add.prepare`、`archive-oa.borrow-car.add.apply` |
+| 契约锁合同 | `archive-oa.qys.contract.list` |
+| 契约锁借阅车 | `archive-oa.qys.borrow-car.list`、`archive-oa.qys.borrow-car.add.prepare`、`archive-oa.qys.borrow-car.add.apply` |
+
+| 发起借阅（生成流程页 URL） | `archive-oa.borrow.start.url`、`archive-oa.qys.borrow.start.url` |
+
+**发起借阅由 `archive-oa.borrow.start.url` 生成流程创建页 URL**：`<baseUrl>/sp/workflow/flowpage/fullCreate/100003460000002090?fb=<fb>&data=<JSON>`，`data` 为 `[{hth, htmc, yfhd, fph}]`。该 operation 只读：不写数据、不触发流程、不需要后台应用凭据；URL 可直接在浏览器打开，表单由用户填写并提交。已下线的 `archive-oa.borrow.start.prepare` / `.apply`（OpenESB webhook）不再提供。
+
+## 两套链路的参数差异
+
+| 项 | 泛微商务合同 | 契约锁协作采纳 |
+| --- | --- | --- |
+| 合同查询 `passid` / `listId` | `850741972510941185` / `850741985437786120` | `850742853046345728` / `1190611964371984450` |
+| 借阅车 `listId` | `882393480417296390` | `883819516961857839` |
+| 加入借阅车 `esbActionIds` | `882395911377174530` | `892706856573648911` |
+
+## 写操作确认协议
+
+- `*.prepare`：只读回查与参数校验（加入借阅车会查一次借阅车现状），返回 `preview` 与 `continuation`。
+- `*.apply`：必须带 `continuation` 且 `confirm: true`（CLI `--yes`）；票据含环境与登录账号指纹，10 分钟有效。
+- 发起借阅用 `archive-oa.borrow.start.url` 生成流程页 URL（只读，`risk: read`）：生成后优先用系统默认浏览器打开，无法打开时原样输出完整 URL；流程表单由用户在浏览器确认并提交。OpenESB 版 `borrow.start.prepare` / `.apply` 已下线。
+- `failNum > 0` 时返回 `partial / write_uncertain`，不自动重放。
+
+## 参考
+
+- `skills/weaver-e10-archive-oa/SKILL.md`：Agent 路由与执行原则。
+- `skills/weaver-e10-archive-oa/references/`：按意图拆分的用法说明。
+- `skill-template/domains/archive-oa.md`：业务域 Agent 调优要点。