weaver-work-cli 0.1.25 → 0.1.28

package/dist/shortcuts/meeting/operations/eb/conflict.js

@@ -26,6 +26,13 @@ import { EB_BASE, ebBusinessSuccess, extractEbRows, queryBody } from './factory.
  * 失败语义与标准版（create.ts 的 runMandatoryConflictChecks）对齐：
  * - 应用设置读取失败：非致命，按「开启检测 + 仅提醒」继续，并在 warnings 中如实说明；
  * - 检测请求本身失败：视为冲突 → 拒绝建会（`conflict_check_failed`），宁可拦住不可漏检。
+ *
+ * 建会路径闸门（2026-10-15 补齐）—— 与冲突检测共用同一次 baseSet 读取：
+ * 文档一直要求「`only_flow_create=1` 或审批开启 → CLI 不直接建会」，但 EB 版 prepare
+ * 只在**文档层**要求、**代码层没有拦**，于是应用设置 `only_flow_create=1` 时
+ * `meeting.eb.meeting.create.prepare` 仍放行、`apply` 照样落库（真机复现：产生
+ * `request_id` 为空、绕过流程的会议）。现由 `assertEbCreatePathAllowed` 在 prepare 阶段
+ * 直接拒绝（`conflict_rejected`），读不到应用设置则保守拒绝（`conflict_check_failed`）。
  */
 /** 候选会议的有效状态：1审批中 / 2未开始 / 8已结束 / 9进行中。 */
 const ACTIVE_MT_STATUS = '1,2,8,9';
@@ -69,8 +76,11 @@ async function listAllEbRows(env, interfacePk, baseQuery, operation) {
     }
     return { rows, requests };
 }
-/** 读取应用设置（query_meeting_baseset，返回 1 条，多条取第一条）中的冲突策略。 */
-export async function fetchEbConflictPolicy(env, operation) {
+/**
+ * 读取应用设置（query_meeting_baseset，返回 1 条，多条取第一条）：
+ * 同时取「冲突策略」与「建会路径开关」，一次请求供两处使用。
+ */
+export async function fetchEbAppSettings(env, operation) {
     try {
         const rows = await requestEbList(env, 'query_meeting_baseset', { pageNo: 1, pageSize: 5 }, operation);
         const base = rows[0] ?? {};
@@ -79,6 +89,10 @@ export async function fetchEbConflictPolicy(env, operation) {
             roomAction: String(base.room_conflict ?? ''),
             memberChk: String(base.member_conflict_chk ?? ''),
             memberAction: String(base.member_conflict ?? ''),
+            onlyFlowCreate: String(base.only_flow_create ?? ''),
+            openMtApprove: String(base.open_mt_approve ?? ''),
+            mtNewWf: String(base.mt_new_wf ?? ''),
+            mtRepeatNewWf: String(base.mt_repeat_new_wf ?? ''),
         };
     }
     catch (error) {
@@ -87,10 +101,50 @@ export async function fetchEbConflictPolicy(env, operation) {
             roomAction: '',
             memberChk: '',
             memberAction: '',
+            onlyFlowCreate: '',
+            openMtApprove: '',
+            mtNewWf: '',
+            mtRepeatNewWf: '',
             error: errorText(error),
         };
     }
 }
+/**
+ * 建会路径闸门（2026-10-15 补齐，口径与标准版 `create.ts` 的 `assertCreatePathAllowed` 对齐）。
+ *
+ * 规则：
+ * - `only_flow_create=1`（只允许通过流程新建会议）→ 拒绝：应用明确不允许流程之外建会；
+ * - `open_mt_approve=1`（会议提交需审批）→ 同样拒绝：会议须由 `mt_new_wf` 流程/ESB 创建，
+ *   手动 `create_meeting` 会绕开审批并产生重复记录（references 实测曾出现 4 条同名会议）；
+ * - 应用设置**读不到** → 无法判定是否允许直接建会 ⇒ 保守拒绝（宁可拦住，不可绕过管控）；
+ * - 开关为空 / 非 `1` → 放行（交由后续冲突检测与用户确认）。
+ *
+ * 拒绝后 CLI 不代为发起流程（流程集成不在本模块范围），只把已确认的信息交回调用方，
+ * 由调用方转 `weaver-e10-workflow`。
+ */
+export function assertEbCreatePathAllowed(settings) {
+    if (settings.error) {
+        throw meetingConflictError('conflict_check_failed', `无法读取会议应用设置（query_meeting_baseset），无法判定是否允许直接建会（only_flow_create / open_mt_approve），已按保守策略拒绝：${settings.error}`);
+    }
+    const blocked = [];
+    if (settings.onlyFlowCreate === '1') {
+        blocked.push('only_flow_create=1（只允许通过流程新建会议）');
+    }
+    if (settings.openMtApprove === '1') {
+        blocked.push('open_mt_approve=1（会议提交需审批）');
+    }
+    if (blocked.length === 0)
+        return;
+    throw meetingConflictError('conflict_rejected', `应用设置不允许直接建会：${blocked.join('；')}。该应用的会议必须经流程创建`
+        + `（新建会议工作流 mt_new_wf=${settings.mtNewWf || '未配置'}，周期会议工作流 mt_repeat_new_wf=${settings.mtRepeatNewWf || '未配置'}）——`
+        + 'CLI 不直接建会、也不代替流程建会（否则会产生流程之外、request_id 为空的会议，且与流程/ESB 自动建会重复）。'
+        + '请改用 weaver-e10-workflow 发起流程建会；如需 CLI 直接建会，请管理员先在会议应用设置中关闭该开关。', {
+        onlyFlowCreate: settings.onlyFlowCreate,
+        openMtApprove: settings.openMtApprove,
+        mtNewWf: settings.mtNewWf,
+        mtRepeatNewWf: settings.mtRepeatNewWf,
+    });
+}
 /** 会议室冲突：查占用视图（query_roomusage_list），时间重叠即冲突。 */
 async function checkRoomConflict(roomId, begin, end, excludeMtId, env, operation) {
     const { rows, requests } = await listAllEbRows(env, 'query_roomusage_list', 
@@ -179,7 +233,8 @@ export async function runEbConflictCheck(input, env, operation, options = {}) {
     const begin = assertDateTimeMinute(input.beginDatetime, 'begin_datetime');
     const end = assertDateTimeMinute(input.endDatetime, 'end_datetime');
     const warnings = [];
-    const policy = await fetchEbConflictPolicy(env, operation);
+    // 调用方（建会/变更 preflight）已读过应用设置时直接复用，避免为闸门与冲突各发一次请求。
+    const policy = options.settings ?? await fetchEbAppSettings(env, operation);
     const outcome = { warnings, policy };
     if (policy.error) {
         warnings.push(`应用设置（query_meeting_baseset）读取失败，冲突策略按「开启检测 + 仅提醒」处理：${policy.error}`);
@@ -268,20 +323,31 @@ export async function runEbConflictCheck(input, env, operation, options = {}) {
     return outcome;
 }
 /**
- * 建会/变更 prepare 的前置钩子：EB 版补上强制冲突检测。
- * 仅在拿到起止时间、且传了 address / hrm_members 时才发请求（无目标即无冲突可言）。
+ * 建会/变更 prepare 的前置钩子：EB 版补上**建会路径闸门**与强制冲突检测。
+ *
+ * 顺序（重要）：
+ * 1. 建会（`create_meeting`）**先过路径闸门** —— 应用设置不允许直接建会时直接拒绝，
+ *    连冲突检测都不必做（结论已定局）；读应用设置失败同样拒绝。
+ * 2. 冲突检测仅在拿到起止时间、且传了 address / hrm_members 时才发请求（无目标即无冲突）。
  */
 export const ebMeetingWritePreflight = async ({ endpoint, payload, args, env }) => {
-    if (endpoint.interfacePk !== 'create_meeting' && endpoint.interfacePk !== 'change_meeting')
+    const isCreate = endpoint.interfacePk === 'create_meeting';
+    const isChange = endpoint.interfacePk === 'change_meeting';
+    if (!isCreate && !isChange)
         return [];
-    // 载荷自 2026-09-21 起为结构化（mainTable + details），冲突检测只关心主表字段。
+    const operation = isChange ? 'meeting.eb.meeting.change.prepare' : 'meeting.eb.meeting.create.prepare';
+    // 载荷自 2026-09-21 起为结构化（mainTable + details），闸门与冲突检测都只关心主表字段。
     const main = payload.mainTable;
-    const begin = main.begin_datetime;
-    const end = main.end_datetime;
-    if (typeof begin !== 'string' || typeof end !== 'string' || !begin || !end)
-        return [];
+    const begin = typeof main.begin_datetime === 'string' ? main.begin_datetime : '';
+    const end = typeof main.end_datetime === 'string' ? main.end_datetime : '';
     const address = typeof main.address === 'string' && main.address ? main.address : undefined;
     const hrmMembers = typeof main.hrm_members === 'string' && main.hrm_members ? main.hrm_members : undefined;
+    // 建会必读应用设置（闸门）；变更只在确有冲突检测目标时才读（避免多一次请求）。
+    const settings = isCreate || address || hrmMembers ? await fetchEbAppSettings(env, operation) : undefined;
+    if (settings && isCreate)
+        assertEbCreatePathAllowed(settings);
+    if (!begin || !end)
+        return [];
     if (!address && !hrmMembers)
         return [];
     const outcome = await runEbConflictCheck({
@@ -291,7 +357,7 @@ export const ebMeetingWritePreflight = async ({ endpoint, payload, args, env })
         ...(hrmMembers ? { hrmMembers } : {}),
         ...(typeof main.org_members === 'string' && main.org_members ? { orgMembers: main.org_members } : {}),
         ...(typeof args.id === 'string' || typeof args.id === 'number' ? { excludeMtId: String(args.id) } : {}),
-    }, env, endpoint.operation === 'meeting.eb.meeting.change' ? 'meeting.eb.meeting.change.prepare' : 'meeting.eb.meeting.create.prepare');
+    }, env, operation, settings ? { settings } : {});
     return outcome.warnings;
 };
 /** 只查不建：会议室冲突检测 operation。 */

package/dist/shortcuts/okr/host.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
 import { getActiveProfile } from '../../internal/e10/auth/session.js';
 import { requireE10Session } from '../../internal/e10/context.js';
 import { E10ApiError, createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
@@ -143,7 +144,7 @@ export function createOkrHost(ctx, dependencies = {}) {
             mapRuntimeNetworkError(error);
         }
         if (response.status === 401 || response.status === 302) {
-            throw okrAuthError('session_expired', 'E10 登录态已失效，请先向用户确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url E10_DOMAIN --agent_type AGENT_NAME 完成登录', { httpStatus: response.status });
+            throw okrAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
         }
         if (response.parseError) {
             throw okrNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });

package/dist/shortcuts/plan/host.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
 import { getActiveProfile } from '../../internal/e10/auth/session.js';
 import { requireE10Session } from '../../internal/e10/context.js';
 import { E10ApiError, createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
@@ -150,7 +151,7 @@ export function createPlanHost(ctx, dependencies = {}) {
             mapRuntimeNetworkError(error);
         }
         if (response.status === 401 || response.status === 302) {
-            throw planAuthError('session_expired', 'E10 登录态已失效，请先向用户确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url <域名> 完成登录', { httpStatus: response.status });
+            throw planAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
         }
         if (response.parseError) {
             throw planNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });

package/dist/shortcuts/project/host.js

@@ -1,3 +1,4 @@
+import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
 import { getActiveProfile } from '../../internal/e10/auth/session.js';
 import { requireE10Session } from '../../internal/e10/context.js';
 import { E10ApiError, createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
@@ -133,7 +134,7 @@ export function createProjectHost(ctx, dependencies = {}) {
             mapRuntimeNetworkError(error);
         }
         if (response.status === 401 || response.status === 302) {
-            throw projectAuthError('session_expired', 'E10 登录态已失效，请先完成登录或重新登录', {
+            throw projectAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, {
                 httpStatus: response.status,
             });
         }

package/dist/shortcuts/workflow/endpoints.js

@@ -50,6 +50,11 @@ export const WORKFLOW_ENDPOINTS = {
     /** 我发起总数 / 列表 */
     MINE_TOTAL: '/api/workflow/list/total/getMineListTotal',
     MINE_LIST: '/api/workflow/list/data/getMineListData',
+    /**
+     * 我发起——**工作流树**（`data.data[]` = 流程大类，`children` = 具体工作流，`id` 形如 `wf_<workflowId>`）。
+     * 入参与 `MINE_LIST` 一致、去掉分页参数。发起侧消歧用（2026-10-20）。
+     */
+    MINE_TREE: '/api/workflow/list/tree/getMineListTree',
     /** 全部总数 / 列表 */
     ALL_TOTAL: '/api/workflow/list/total/getAllListTotal',
     ALL_LIST: '/api/workflow/list/data/getAllListData',
@@ -138,6 +143,12 @@ export const FORM_ENDPOINTS = {
     verificationConditionRule: '/api/bs/workflow/pathdef/nodeConformance/verificationConditionRule',
     /** 提交已创建的流程（创建后页面重载拿到 view 页鉴权再提交，与真机同路径） */
     flowSubmit: '/api/workflow/core/flow/submit',
+    /**
+     * 签字意见的默认样式（字体 / 字号 / 是否纯文本输入）。
+     *
+     * 提交前取一次，用来把意见内容包成服务端能正确渲染的富文本形态；取不到就退回原样式。
+     */
+    signInputInfo: '/api/workflow/core/flowPage/loadSignInputInfo',
     /** 租户级文件上传设置（单文件大小上限 + 格式黑白名单） */
     tenantSetting: '/api/file/tenant/setting',
 };

package/dist/shortcuts/workflow/host.js

@@ -1,3 +1,4 @@
+import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
 import { requireE10Session } from '../../internal/e10/context.js';
 import { getActiveProfile } from '../../internal/e10/auth/session.js';
 import { createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
@@ -118,9 +119,6 @@ export function extractApiBusinessError(payload) {
     }
     return '';
 }
-function loginExpiredMessage() {
-    return 'OA 登录状态或系统认证信息无效，本次任务已停止。请先向用户确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url <域名> --agent_type <当前智能体名称> 完成登录，随后重放原请求。';
-}
 export function createWorkflowHost(ctx, dependencies = {}) {
     let session = null;
     let sessionContext = null;
@@ -150,7 +148,7 @@ export function createWorkflowHost(ctx, dependencies = {}) {
         return sessionContext;
     }
     async function run(request, responseType) {
-        const { method = 'POST', path, query, body, form, formData, operation, timeoutMs = DEFAULT_TIMEOUT_MS, } = request;
+        const { method = 'POST', path, query, headers, body, form, formData, operation, timeoutMs = DEFAULT_TIMEOUT_MS, } = request;
         const runtime = createE10RequestRuntime(ctx, await ensureSession(), {
             interceptors: dependencies.interceptors,
             fetch: dependencies.fetch,
@@ -160,7 +158,7 @@ export function createWorkflowHost(ctx, dependencies = {}) {
         });
         let response;
         try {
-            const base = { method, path, query, body, form, formData, operation, timeoutMs, module: 'workflow' };
+            const base = { method, path, query, headers, body, form, formData, operation, timeoutMs, module: 'workflow' };
             response = responseType === 'binary'
                 ? await runtime.requestBinary(base)
                 : await runtime.requestJson(base);
@@ -174,7 +172,7 @@ export function createWorkflowHost(ctx, dependencies = {}) {
         }
         if ('content' in response) {
             if (isLoginExpired({}, response.status)) {
-                throw workflowAuthError('session_expired', loginExpiredMessage(), { httpStatus: response.status });
+                throw workflowAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
             }
             return {
                 status: response.status,
@@ -184,7 +182,7 @@ export function createWorkflowHost(ctx, dependencies = {}) {
             };
         }
         if (isLoginExpired(response.value, response.status)) {
-            throw workflowAuthError('session_expired', loginExpiredMessage(), {
+            throw workflowAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, {
                 httpStatus: response.status,
                 details: { endpointKey: operation, response: response.value },
             });

package/dist/shortcuts/workflow/index.js

@@ -81,47 +81,17 @@ function failureEnvelope(error) {
  */
 export { compactStdoutPaths };
 /**
- * 「stdout 整体直出」的判定 —— 目前**只有小e 环境的 `BROWSER_FILL` 一档**适用。
- *
- * 用户 2026-10-15 裁定：「xiaoe 下应该直接输出 `<browsertool>` 标签」。即该档的 stdout **就是**
- * 那段标签块本身，**不再套** `{schemaVersion, ok, operation, data, warnings}` 信封 —— 于是
- * `workflow-create.md` 里「返回内容以 `<browsertool>` 开头 ⇒ 原样输出」这句是**字面成立**的。
- * 代价（用户已知悉并接受）：这一档模型拿不到 `status` / `contextId`（本档不写服务端、句柄也未消费，
- * 需要重发时由用户重新发起即可）。
- *
- * 两个条件必须同时成立，缺一就退回信封 —— 宁可不直出，也不让调用方拿到半截或空输出：
- * - `data.status === 'BROWSER_FILL'`：小e 专用档，其它状态（含 `NEEDS_INPUT`）一律维持信封；
- * - `data.finalMarkdown` 以 `<browsertool>` 开头：与文档口径同字面，渲染档万一变了也不会直出一个
- *   看起来像标签、实际不是的东西。
- *
- * 必须走 `ctx.output.raw()` 而不是 `write(value, { text })`：后者在**全局 `--json`** 下仍会退化成
- * JSON（`core/output.ts`：`useJson = globalOptions.json || options.json || !options.text`），
- * 而本 skill 的文档一律带 `--json`。
- */
-export function rawStdoutOf(result) {
-    const data = result.data;
-    if (!data || typeof data !== 'object')
-        return undefined;
-    if (data.status !== 'BROWSER_FILL')
-        return undefined;
-    const markdown = data.finalMarkdown;
-    if (typeof markdown !== 'string' || !markdown.startsWith('<browsertool>'))
-        return undefined;
-    return markdown;
-}
-/**
- * 把一次 operation 的结果打到 stdout —— **形态二选一**（判定见 `rawStdoutOf`）。
+ * 把一次 operation 的结果打到 stdout —— **只有一种形态：JSON 信封**。
  *
  * 独立成函数并**导出**，是为了让用例直接锁住这条接线（与 `compactStdoutPaths` 同一理由：
  * 回归要在这里红，而不是等到真机上模型拿到一份"既不是 JSON、也不是标签块"的东西才发现）。
+ *
+ * ★ 2026-10-21 用户裁定（**改口径**）：小e 的 `BROWSER_FILL` 档**不再直出** `<browsertool>` 标签块，
+ * 一律走 JSON 信封 —— 标签块放在 `data.finalMarkdown` 里，与 `createRequestDirect` 统一成一种结构，
+ * 于是 `durationMs` / `apiDurations` / `apiSlowest` / `authMs` 四个耗时键在这一档也可见。
+ * 原来的 `rawStdoutOf()` 直出通道随之删除（它当时只为"stdout 就是标签块"服务）。
  */
 export function printWorkflowResult(ctx, operation, result) {
-    const raw = rawStdoutOf(result);
-    if (raw !== undefined) {
-        // 小e：stdout 就是标签块本身 —— 不套信封、不进 `prepare()` 的超线落盘（这段本来就不长）。
-        ctx.output.raw(raw);
-        return;
-    }
     ctx.output.write(successEnvelope(operation, result), {
         json: true,
         compactPaths: compactStdoutPaths(operation),

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

@@ -0,0 +1,252 @@
+/**
+ * 智能填参：调 OA 的 `chatScene` 接口，让一个**独立智能体**把「用户意图 + 表单字段上下文」
+ * 映射成可直接喂给 `createRequest` 的 `data` 参数。
+ *
+ * ## 接口契约（来源：2026-10-19 真机 HAR，HTTP 200）
+ *
+ * ```
+ * POST {baseUrl}/api/ai/application/chat/chatScene
+ * aiappuniquekey: workflow_form_filler
+ * Content-Type: application/json;charset=UTF-8
+ * ```
+ *
+ * - body 里 `chatId`（19 位数字串）/ `taskId` / `userMessageId`（32 位无横线 hex）**每次随机**，
+ *   其余字段与值固定；
+ * - `messages[0].content` 是**字符串**（入参 JSON 序列化后的文本），**不是对象**；
+ * - 返回的 `data.chatMessage.content` 同样是**字符串**，要**二次 `JSON.parse`**；
+ * - **同步返回**（真机 `timeConsuming.all = 3592 ms`），不需要轮询 —— `pollingInterval` 在本场景不起作用。
+ *
+ * ## 失败口径
+ *
+ * 这个接口是**增强**而不是前置依赖：拿不到合法结果就返回 `ok:false`，由调用方原样退回旧口径
+ * （保留 `historyRequestData` / `systemFields`）。**任何异常都不向上抛**，绝不因为智能体故障
+ * 把整个发起流程打死。
+ */
+import { randomUUID } from 'node:crypto';
+/** 智能体应用标识。注意是**下划线**形态（不是早期的 `workflow-form-filler`）。 */
+export const CHATSCENE_APP_UNIQUE_KEY = 'workflow_form_filler';
+/** 接口路径（`/api/` 前缀是 host 的强制要求）。 */
+export const CHATSCENE_PATH = '/api/ai/application/chat/chatScene';
+/**
+ * 单独超时：真机 3.6 s，但这是**外部大模型**调用，可能排队。
+ *
+ * ★ 2026-10-20 用户裁定：**15 s**（此前 30 s）。实测该智能体真出状况时服务端自身也要挂到 30 s 才回
+ * `InterruptedIOException`，等它没有意义 —— 反正拿不到可用结果就会降级，早 15 s 放弃能让整条
+ * `createForm` 少等一半。失败口径不变（仍静默降级、不打断发起流程）。
+ */
+const CHATSCENE_TIMEOUT_MS = 15_000;
+/**
+ * 填写依据的后缀：智能体在每个字段值旁写 `<字段id>_reason`（实测还会写成 `_reason2`、`_reason3`），
+ * 这些键**必须**在进 `data` 之前剔掉。
+ *
+ * ★ 漏剔一个不是"多提交一个字段"，而是**整张单被卡住**：`createRequest` 的 `bindInputFields`
+ * 会把 `main` / 明细行里的每个键拿去和字段 id / 名称匹配，匹配不到就记一条 `NOT_FOUND` 歧义，
+ * 而 `commandCreateRequest` 一见 `fieldAmbiguities.length` 就直接返回 `NEEDS_CONFIRMATION`。
+ *
+ * 依据本身**只用于调试参数是怎么生成出来的**，不进任何返回面（2026-10-20 用户裁定）。
+ */
+const REASON_KEY = /_reason\d*$/;
+/**
+ * 19 位数字串，形态对齐雪花 ID（真机 `1327983839164596324`）。
+ *
+ * 用 `Date.now() * 1e6 + 随机 6 位`：时间戳保证单调整体、尾 6 位保证同毫秒内不撞。
+ * 必须走 `BigInt` —— `1.79e12 × 1e6 = 1.79e18` 已远超 `Number.MAX_SAFE_INTEGER`（9.0e15），
+ * 用 number 会丢精度、末尾几位变成 0。
+ */
+function randomChatId() {
+    const ts = BigInt(Date.now()) * 1000000n;
+    const seq = BigInt(Math.floor(Math.random() * 1_000_000));
+    return (ts + seq).toString();
+}
+/** 32 位无横线 hex（真机 `taskId` / `userMessageId` 的形态）。 */
+function randomHex32() {
+    return randomUUID().replace(/-/g, '');
+}
+/** 本地时间 `YYYY-MM-DD HH:mm:ss`，供智能体把「今天 / 下周三 / 上个月」换算成绝对日期。 */
+export function formatLocalNow(date = new Date()) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
+        + ` ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+ * 交给智能体的字段属性**白名单** —— 就是智能体入参契约里的那 11 个键，一个不多一个不少
+ * （2026-10-20 用户对齐真机入参）。为此要挡掉 `createForm` 侧那些**只给 CLI 自己用**的属性：
+ *
+ * | 属性 | 为什么不给智能体 |
+ * | --- | --- |
+ * | `initialValue` | 字段默认值：智能体只负责按用户意图产值，不需要（也不该被）默认值影响（2026-10-22 用户裁定去掉） |
+ * | `fileUploadParams` | 文件夹 / 大小格式限制 / 一次性签名，是给调 caizhilian 上传的模型用的；带上它会让智能体误以为要自己判上传限制 |
+ * | `browserType` / `browserModule` | 浏览通道标识，由 CLI 在 `createRequest` 解析值时用，与「意图 → 值」无关 |
+ * | `readOnly` / `disableEdit` / `folderDependsOnOption` | 是否可写、附件文件夹是否随选项变，都是 CLI 侧的门禁/联动细节 |
+ *
+ * 键序与契约一致（`componentKey` → 布尔标记 → `format` → `options`）。
+ */
+const AGENT_FIELD_KEYS = [
+    'id', 'name', 'subFormId', 'componentKey',
+    'isBrowser', 'isSelect', 'isMultiple', 'isEmployeeScope', 'isEinvoice',
+    'format', 'options',
+];
+function pickAgentFields(fields) {
+    const picked = [];
+    for (const field of fields) {
+        if (!field || typeof field !== 'object')
+            continue;
+        const item = {};
+        for (const key of AGENT_FIELD_KEYS) {
+            const value = field[key];
+            if (value === undefined || value === null)
+                continue;
+            item[key] = value;
+        }
+        picked.push(item);
+    }
+    return picked;
+}
+export function buildChatSceneInput(params) {
+    return {
+        userQuestion: params.userQuestion,
+        workflow: { id: String(params.workflow.id ?? ''), name: String(params.workflow.name ?? '') },
+        fields: pickAgentFields(params.fields || []),
+        historyRequestData: params.historyRequestData ?? null,
+        userMemory: String(params.userMemory ?? ''),
+        now: params.now || formatLocalNow(),
+    };
+}
+/** 摘掉一行里的所有依据键（`_reason` / `_reason2` …），只留真值；空值也不留。 */
+function stripReasonKeys(source) {
+    const values = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (REASON_KEY.test(key))
+            continue;
+        if (value === null || value === undefined)
+            continue;
+        values[key] = value;
+    }
+    return values;
+}
+/**
+ * 把智能体返回的 `formData` 收敛成 `{main, details}`，并**摘掉所有依据键**。
+ * 结构不对就返回 null（＝降级）。
+ */
+function normalizeFormData(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const mainRaw = raw.main;
+    const detailsRaw = raw.details;
+    const main = {};
+    if (mainRaw && typeof mainRaw === 'object' && !Array.isArray(mainRaw)) {
+        Object.assign(main, stripReasonKeys(mainRaw));
+    }
+    const details = {};
+    if (detailsRaw && typeof detailsRaw === 'object' && !Array.isArray(detailsRaw)) {
+        for (const [subFormId, rows] of Object.entries(detailsRaw)) {
+            if (!Array.isArray(rows))
+                continue;
+            const kept = [];
+            for (const row of rows) {
+                if (!row || typeof row !== 'object' || Array.isArray(row))
+                    continue;
+                const values = stripReasonKeys(row);
+                // 整行只有依据键、一个值都没有 ⇒ 不产行（否则会多出一行空明细）
+                if (!Object.keys(values).length)
+                    continue;
+                kept.push(values);
+            }
+            if (!kept.length)
+                continue;
+            details[subFormId] = kept;
+        }
+    }
+    // 一个字段都没有 ⇒ 视为没拿到结果（否则会把整张空表单当成"已填好"交出去）
+    if (!Object.keys(main).length && !Object.keys(details).length)
+        return null;
+    return { data: { main, details } };
+}
+/**
+ * `systemData` 只收四个已知键、统一成字符串；缺键 / 非字符串一律当空串。
+ * 四个键的 `_reason` 变体本来就不在白名单里，直接不收。
+ */
+function normalizeSystemData(raw) {
+    const source = (raw && typeof raw === 'object' && !Array.isArray(raw)) ? raw : {};
+    const systemData = {};
+    for (const key of ['requestName', 'requestLevel', 'secLevel', 'remark']) {
+        const value = source[key];
+        systemData[key] = (value === null || value === undefined) ? '' : String(value).trim();
+    }
+    return systemData;
+}
+/**
+ * 调 `chatScene` 并解析结果。**永不抛异常**。
+ *
+ * 判成功的三个条件（缺一即降级，对应需求「返回值 data.chatMessage.content 不存在或者为空则走原逻辑」）：
+ * 1. 外层 `code === 200 && status === true`；
+ * 2. `data.chatMessage.content` 是**非空字符串**；
+ * 3. 该字符串能 parse 成 JSON，且里面有非空的 `formData`。
+ */
+export async function requestFormFill(env, input) {
+    const startedAt = Date.now();
+    const base = () => ({ ok: false, durationMs: Date.now() - startedAt });
+    try {
+        const body = {
+            appUniqueKey: CHATSCENE_APP_UNIQUE_KEY,
+            fromPersonalHome: false,
+            chatId: randomChatId(),
+            appConfigType: 3,
+            // ★ content 必须是**字符串**：整个入参 JSON 序列化一次
+            messages: [{ content: JSON.stringify(input), role: 'user' }],
+            isNeedContext: 1,
+            regenerate: false,
+            pollingInterval: 200,
+            globalParam: {},
+            sessionParam: {},
+            frontToolList: [],
+            searchType: 1,
+            userMessageId: randomHex32(),
+            assist: { fileList: [], quoteContent: '' },
+            taskId: randomHex32(),
+            clientType: 1,
+        };
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: CHATSCENE_PATH,
+            // 该接口靠这个头定位智能体应用；workflow 系列接口不需要它
+            headers: { aiappuniquekey: CHATSCENE_APP_UNIQUE_KEY },
+            body,
+            operation: 'workflow.createForm',
+            timeoutMs: CHATSCENE_TIMEOUT_MS,
+            // 失败要能自己读结论（也避免把 code/status 异常抛成业务错误中断 createForm）
+            tolerateBusinessError: true,
+        });
+        const root = (response && typeof response === 'object') ? response : {};
+        if (Number(root.code) !== 200 || root.status !== true) {
+            return { ...base(), reason: `chatScene 返回 code=${String(root.code)} status=${String(root.status)}` };
+        }
+        const content = root?.data?.chatMessage?.content;
+        if (typeof content !== 'string' || !content.trim()) {
+            return { ...base(), reason: 'chatScene 未返回 chatMessage.content' };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            return { ...base(), reason: 'chatMessage.content 不是合法 JSON' };
+        }
+        const normalized = normalizeFormData(parsed?.formData);
+        if (!normalized)
+            return { ...base(), reason: '返回值里没有可用的 formData' };
+        return {
+            ok: true,
+            data: normalized.data,
+            systemData: normalizeSystemData(parsed?.systemData),
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    catch (error) {
+        // 超时 / 网络 / HTTP 5xx / 登录态以外的任何问题，一律降级，不打断 createForm。
+        const message = (error && typeof error === 'object' && 'message' in error)
+            ? String(error.message)
+            : String(error);
+        return { ...base(), reason: `chatScene 调用失败：${message}` };
+    }
+}