weaver-work-cli 0.1.29 → 0.1.32

package/dist/shortcuts/meeting/operations/eb/create-flow.js

@@ -0,0 +1,710 @@
+import { meetingSuccess, schemaOf, SCHEMA_DATETIME_MINUTE } from '../types.js';
+import { meetingValidationError } from '../../errors.js';
+import { fetchEbAppSettings, findCommonFreeSlots } from './conflict.js';
+import { recommendRooms } from './room-recommend.js';
+/**
+ * 通过**流程**新建 EB 会议（`meeting.eb.meeting.create.flow`）。
+ *
+ * 为什么需要（2026-10-28 用户明确要求）：会议应用设置里勾了「只允许通过流程新建会议」
+ * （`only_flow_create=1`）时，直连 `create_meeting` 是被禁止的；此前的做法是直接抛错让调用方
+ * "去用别的 skill"，等于把活推回去。正确做法是**顺着管控走流程**：载入建会流程表单 → 填会议字段 →
+ * 提交审批 → 会议由流程/ESB 创建 → 会后再补邀请函。
+ *
+ * 链路：`workflow.createForm`（按 mt_new_wf 载入表单）→ 字段名映射 → `workflow.createRequest`
+ * （action=submit）→ 轮询会议列表确认会议已生成 → `meeting.invitation.render` 出邀请函。
+ *
+ * 口径提醒：
+ * - 流程走完（或审批通过）后会议才会真正出现在会议表里，所以**邀请函在确认到会议 id 之后才生成**；
+ *   拿不到会议时返回 `invitation.pending=true`，不要假装已经生成。
+ * - 字段按**中文名**映射（会议名称/开始时间/…），租户改了字段名就在 `fieldAliases` 里补；
+ *   映射不到的字段会原样回到 `unmapped` 里，由调用方决定是否补充。
+ * - 不猜必填项：`workflow.createRequest` 报缺字段时原样返回，由调用方向用户确认。
+ */
+/** 建会流程表单字段的常见别名（租户之间字段名会有出入，按名称匹配，不用 fieldId 写死）。 */
+const FIELD_ALIASES = {
+    mt_name: ['会议名称', '会议主题', '主题'],
+    begin_datetime: ['开始时间', '会议开始时间'],
+    end_datetime: ['结束时间', '会议结束时间'],
+    mt_desc: ['会议内容', '会议说明', '会议描述'],
+    address: ['会议地点', '会议室'],
+    customize_address: ['自定义会议地点', '自定义地点'],
+    hrm_members: ['参会人员', '参会人'],
+    total_member: ['参会人数', '人数'],
+    caller: ['召集人', '发起人'],
+    contacter: ['联系人'],
+    mt_type: ['会议类型'],
+    other_remark: ['备注', '其他说明'],
+};
+function workflowEnv(env) {
+    return env;
+}
+/** 载入建会流程表单（拿 contextId/continuation/字段清单）。 */
+async function loadCreateForm(env, workflowId) {
+    const { createWorkflowHost } = await import('../../../workflow/host.js');
+    const { createWorkflowContinuationSigner } = await import('../../../workflow/continuation.js');
+    const { getWorkflowOperation } = await import('../../../workflow/operations/registry.js');
+    const wfEnv = {
+        ...workflowEnv(env),
+        host: createWorkflowHost(env.ctx),
+        continuation: createWorkflowContinuationSigner(env.ctx),
+    };
+    const operation = getWorkflowOperation('workflow.createForm');
+    const result = await operation.handler({ workflow: [workflowId] }, wfEnv);
+    const data = result?.data ?? {};
+    if (data.status !== 'FORM_READY') {
+        throw meetingValidationError('flow_form_unavailable', `建会流程表单载入失败（status=${String(data.status)}）：${String(data.clarificationQuestion ?? data.note ?? '').slice(0, 200)}`, { workflowId });
+    }
+    const wf = data.workflow ?? {};
+    return {
+        fields: (data.fields ?? []),
+        continuation: data.continuation,
+        requestName: data.requestName,
+        contextId: data.contextId,
+        workflowName: String(wf.name ?? wf.workflowName ?? '').trim() || undefined,
+    };
+}
+/** 取员工姓名（hrm.employee.batch，一次批量，失败返回空表不阻塞）。 */
+async function resolveEmployeeNames(env, ids) {
+    const map = new Map();
+    const unique = [...new Set(ids.map((id) => String(id).trim()).filter((id) => id !== ''))];
+    if (unique.length === 0)
+        return map;
+    try {
+        const { hrmEmployeeOperations } = await import('../../../hrm/operations/employee.js');
+        const batch = hrmEmployeeOperations.find((operation) => operation.name === 'hrm.employee.batch');
+        if (!batch)
+            return map;
+        const result = await batch.handler({ ids: unique }, env);
+        const rows = (result?.data?.rows ?? result?.data?.userList ?? []);
+        for (const row of rows) {
+            const id = String(row.id ?? '').trim();
+            const name = String(row.name ?? '').trim();
+            if (id && name)
+                map.set(id, name);
+        }
+    }
+    catch {
+        // 查不到姓名就退回「以 id 当名称」，工作流多数能按 id 直接命中
+    }
+    return map;
+}
+/** 会议室 id → {id,name}（优先会议室缓存，缓存没有就查一次详情）。 */
+async function resolveRoomValue(env, input) {
+    const text = String(input ?? '').trim();
+    if (!text)
+        return null;
+    const { loadRooms } = await import('./room-recommend.js');
+    try {
+        const { rooms } = await loadRooms(env, {});
+        const byId = rooms.find((room) => room.id === text);
+        if (byId)
+            return { id: byId.id, name: byId.name };
+        const byName = rooms.find((room) => room.name === text);
+        if (byName)
+            return { id: byName.id, name: byName.name };
+    }
+    catch {
+        // 缓存读不到就退到详情
+    }
+    if (/^\d+$/.test(text)) {
+        try {
+            const { getMeetingOperation } = await import('../registry.js');
+            const detail = await getMeetingOperation('meeting.eb.room.detail').handler({ id: text }, env);
+            const main = detail?.data?.mainTable ?? detail?.data?.data?.mainTable ?? {};
+            const name = String(main.room_name ?? '').trim();
+            if (name)
+                return { id: text, name };
+        }
+        catch {
+            // 详情也拿不到就只传 id
+        }
+        return { id: text, name: text };
+    }
+    return null;
+}
+/**
+ * 浏览按钮字段要传 **{id,name}**（不能只传 id 或只传名字）。
+ *
+ * 2026-10-28 真机踩坑：把「会议地点/参会人员/召集人」当普通文本传 id，工作流把它们当"名称"去
+ * getRelateData 里匹配，匹配不到就返回 NEEDS_CONFIRMATION（"无法唯一解析的选项"）——
+ * 看起来像"流程建会走不通"，其实是值格式不对。这里统一补成对象。
+ */
+async function shapeBrowserValues(env, values) {
+    const notes = [];
+    const shaped = { ...values };
+    if (shaped.address !== undefined && shaped.address !== '') {
+        const room = await resolveRoomValue(env, String(shaped.address));
+        if (room) {
+            shaped.address = room;
+            notes.push(`会议地点按浏览按钮格式提交：${room.name}(${room.id})`);
+        }
+    }
+    const personFields = ['hrm_members', 'caller', 'contacter'];
+    const idPool = [];
+    for (const key of personFields) {
+        const raw = shaped[key];
+        if (raw === undefined || raw === '')
+            continue;
+        const ids = String(raw).split(/[,;，；\s]+/).map((item) => item.trim()).filter((item) => item !== '');
+        idPool.push(...ids);
+    }
+    if (idPool.length > 0) {
+        const names = await resolveEmployeeNames(env, idPool);
+        const toObject = (id) => ({ id, name: names.get(id) ?? id });
+        if (shaped.hrm_members !== undefined && shaped.hrm_members !== '') {
+            const ids = String(shaped.hrm_members).split(/[,;，；\s]+/).map((item) => item.trim()).filter((item) => item !== '');
+            shaped.hrm_members = ids.map(toObject);
+            notes.push(`参会人员按浏览按钮格式提交：${ids.length} 人`);
+        }
+        if (shaped.caller !== undefined && shaped.caller !== '') {
+            const id = String(shaped.caller).trim();
+            shaped.caller = toObject(id);
+        }
+        if (shaped.contacter !== undefined && shaped.contacter !== '') {
+            const id = String(shaped.contacter).trim();
+            shaped.contacter = toObject(id);
+        }
+    }
+    return { values: shaped, notes };
+}
+/** 按别名把会议字段映射到表单字段 id。 */
+function mapFields(fields, values) {
+    const byName = new Map(fields.map((field) => [field.name.trim(), field]));
+    const main = {};
+    const mapped = {};
+    const unmapped = [];
+    for (const [key, raw] of Object.entries(values)) {
+        if (raw === undefined || raw === null || raw === '')
+            continue;
+        const aliases = FIELD_ALIASES[key] ?? [];
+        const hit = aliases.map((name) => byName.get(name)).find((field) => field !== undefined);
+        if (!hit) {
+            unmapped.push(key);
+            continue;
+        }
+        main[hit.id] = raw;
+        mapped[key] = `${hit.name}(${hit.id})`;
+    }
+    return { main, mapped, unmapped };
+}
+/** 解析要用的建会流程 id：入参优先，其次取应用设置里的 mt_new_wf（逗号分隔取第一个）。 */
+async function resolveWorkflowId(env, args) {
+    const explicit = String(args.workflowId ?? '').trim();
+    if (explicit)
+        return { workflowId: explicit, candidates: [explicit] };
+    const settings = await fetchEbAppSettings(env, 'meeting.eb.meeting.create.flow.prepare');
+    const candidates = String(settings.mtNewWf ?? '')
+        .split(/[,;，；\s]+/)
+        .map((item) => item.trim())
+        .filter((item) => item !== '');
+    if (candidates.length === 0) {
+        throw meetingValidationError('flow_not_configured', '应用设置里没有配置「新建会议工作流」（mt_new_wf 为空），无法走流程建会；请管理员在会议应用设置里配置，或关闭「只允许通过流程新建会议」');
+    }
+    // 多个流程时先不拍板：由调用方探测"当前人员对每个流程有没有发起权限"，再决定是否让用户选。
+    return { workflowId: candidates.length === 1 ? candidates[0] : '', candidates };
+}
+const ebMeetingCreateFlowPrepare = {
+    name: 'meeting.eb.meeting.create.flow.prepare',
+    resource: 'eb',
+    method: 'meeting.eb.meeting.create.flow.prepare',
+    action: 'meeting.eb.meeting.create.flow.prepare',
+    summary: '流程建会（准备）：按应用设置 mt_new_wf 载入建会流程表单，把会议字段按中文名映射成表单值，返回预览与确认票据（不提交）',
+    capability: 'eb.meeting',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        mt_name: { type: 'string', description: '会议名称（必填）' },
+        begin_datetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
+        end_datetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+        mt_desc: { type: 'string', description: '会议内容/说明' },
+        address: { type: 'string', description: '会议室（名称或 id，按流程表单字段要求）' },
+        customize_address: { type: 'string', description: '自定义会议地点' },
+        hrm_members: { type: 'string', description: '参会人员（逗号分隔员工 id 或姓名，按流程表单要求）' },
+        total_member: { type: 'number', description: '参会人数' },
+        caller: { type: 'string', description: '召集人' },
+        contacter: { type: 'string', description: '联系人' },
+        other_remark: { type: 'string', description: '备注' },
+        workflowId: { type: 'string', description: '指定建会流程 id（默认取应用设置 mt_new_wf 的第一个）' },
+        autoRoom: { type: 'boolean', description: '默认 false：未指定会议室时返回候选让用户选；传 true 才自动采用推荐' },
+        allowNoRoom: { type: 'boolean', description: '确实不需要会议室（线上会等）时传 true，避免被“请选择会议室”拦住' },
+    }, { required: ['mt_name', 'begin_datetime', 'end_datetime'] }),
+    handler: async (args, env) => {
+        const resolved = await resolveWorkflowId(env, args);
+        const candidates = resolved.candidates;
+        let workflowId = resolved.workflowId;
+        const probes = [];
+        const loadedForms = new Map();
+        if (!workflowId && candidates.length > 1) {
+            // 应用设置里配了多个建会流程：**逐个探测当前人员能否发起**（createForm 能载入 = 有发起权限），
+            // 不能默认拿第一个就提交 —— 用户可能对第一个没有发起权限（2026-10-28 用户要求）。
+            // 并行探测：每个流程一次 createForm（内含多次 OA 请求），串行会成倍放大等待
+            const probed = await Promise.all(candidates.map(async (id) => {
+                try {
+                    const probeForm = await loadCreateForm(env, id);
+                    return {
+                        id,
+                        probeForm,
+                        probe: {
+                            workflowId: id,
+                            ...(probeForm.workflowName ? { name: probeForm.workflowName } : {}),
+                            launchable: true,
+                        },
+                    };
+                }
+                catch (error) {
+                    return {
+                        id,
+                        probeForm: null,
+                        probe: {
+                            workflowId: id,
+                            launchable: false,
+                            reason: String(error?.message ?? error).slice(0, 160),
+                        },
+                    };
+                }
+            }));
+            for (const item of probed) {
+                if (item.probeForm)
+                    loadedForms.set(item.id, item.probeForm);
+                probes.push(item.probe);
+            }
+            const launchable = probes.filter((probe) => probe.launchable);
+            if (launchable.length === 0) {
+                throw meetingValidationError('flow_not_launchable', `应用设置配置了 ${candidates.length} 个建会流程，但当前账号一个都发起不了（无发起权限或流程已停用）：`
+                    + probes.map((probe) => `${probe.workflowId}（${probe.reason ?? '不可发起'}）`).join('；'), { probes });
+            }
+            if (launchable.length > 1) {
+                // 仍有多个可选 → 交给用户挑，不替用户决定（用户明确要求"以选择的方式"）
+                return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                    status: 'NEEDS_SELECTION',
+                    message: `当前账号可发起 ${launchable.length} 个建会流程，请让用户选择要触发哪一个`,
+                    options: launchable.map((probe, index) => ({
+                        key: `W${index + 1}`,
+                        label: probe.name ? `${probe.name}（${probe.workflowId}）` : probe.workflowId,
+                        value: { workflowId: probe.workflowId },
+                        reason: '当前账号有发起权限',
+                    })),
+                    probes,
+                }, {
+                    warnings: [
+                        `检测到 ${candidates.length} 个建会流程，其中 ${launchable.length} 个当前账号可发起；`
+                            + '请把这几个流程做成选项让用户挑一个，选定后带 workflowId 重新 prepare。',
+                        ...probes.filter((probe) => !probe.launchable)
+                            .map((probe) => `流程 ${probe.workflowId} 当前账号无法发起（${probe.reason ?? '无权限'}），已排除`),
+                    ],
+                });
+            }
+            workflowId = launchable[0].workflowId;
+        }
+        const form = loadedForms.get(workflowId) ?? await loadCreateForm(env, workflowId);
+        if (!form.continuation) {
+            throw meetingValidationError('flow_context_missing', '建会流程表单没有返回 continuation，无法继续提交');
+        }
+        // 走流程也要有"选会议室 / 选时间"的体验（2026-10-28 用户要求）。
+        // ⚠️ 性能：会议室推荐、参会人冲突、共同空闲时段三件事**互相独立**，必须并行发；
+        // 串行会把 3 段网络耗时叠加成"建个会要等好几分钟"（用户 2026-10-28 反馈）。
+        const decisions = {};
+        // enrich=false：只做"建会必需"的事（载入表单 + 填字段 + 提交），跳过会议室推荐/冲突检测/空闲时段。
+        // 适用场景：人、时间、房间都已经确定，只想尽快把会建出来（可省掉 3 组额外请求与一次 ESB 调用）。
+        const enrich = args.enrich !== false;
+        const beginText = String(args.begin_datetime ?? '').trim();
+        const endText = String(args.end_datetime ?? '').trim();
+        const memberIds = String(args.hrm_members ?? '')
+            .split(/[,;，；\s]+/)
+            .map((item) => item.trim())
+            .filter((item) => item !== '');
+        let addressInput = args.address;
+        const day = beginText.slice(0, 10);
+        const durationMinutes = beginText && endText
+            ? Math.max(15, Math.round((Date.parse(endText.replace(' ', 'T')) - Date.parse(beginText.replace(' ', 'T'))) / 60000) || 60)
+            : 60;
+        const timings = {};
+        const startedAt = Date.now();
+        const roomTask = (enrich && !addressInput && beginText && endText)
+            ? recommendRooms(env, {
+                beginDatetime: beginText,
+                endDatetime: endText,
+                ...(memberIds.length > 0 ? { memberCount: memberIds.length } : {}),
+                topN: 3,
+            }).catch(() => null)
+            : Promise.resolve(null);
+        const conflictTask = (enrich && beginText && endText && memberIds.length > 0)
+            ? (async () => {
+                const { getMeetingOperation } = await import('../registry.js');
+                return getMeetingOperation('meeting.eb.conflict.member').handler({ beginDatetime: beginText, endDatetime: endText, hrmMembers: memberIds.join(',') }, env);
+            })().catch(() => null)
+            : Promise.resolve(null);
+        const availabilityTask = (enrich && beginText && endText && memberIds.length > 0)
+            ? findCommonFreeSlots(env, {
+                rangeStart: `${day} 00:00`,
+                rangeEnd: `${day} 23:59`,
+                durationMinutes,
+                members: memberIds,
+                maxSlots: 3,
+                maxDays: 1,
+                includeSchedule: true,
+            }).catch(() => null)
+            : Promise.resolve(null);
+        const [roomRec, memberConflict, free] = await Promise.all([roomTask, conflictTask, availabilityTask]);
+        timings.parallelMs = Date.now() - startedAt;
+        if (roomRec) {
+            const roomOptions = roomRec.candidates.map((candidate, index) => ({
+                key: `R${index + 1}`,
+                label: `${candidate.name}${candidate.capacity.max > 0 ? `（可容 ${candidate.capacity.max} 人）` : ''}`
+                    + `${index === 0 ? ' · 推荐' : ''}`,
+                value: { id: candidate.id, name: candidate.name },
+                reason: candidate.reasons.join('；'),
+            }));
+            decisions.roomOptions = roomOptions;
+            decisions.autoRoom = {
+                picked: roomRec.best
+                    ? { id: roomRec.best.id, name: roomRec.best.name, score: roomRec.best.score, reasons: roomRec.best.reasons }
+                    : null,
+                candidates: roomRec.candidates,
+                meta: roomRec.meta,
+            };
+            // 会议室**不替用户决定**（用户明确要求：即使是常用会议室，也必须推荐出来让选择）。
+            // 只有显式 `autoRoom: true` 才自动选中；否则返回 NEEDS_SELECTION，把候选交给调用方去问。
+            const autoRoom = args.autoRoom === true;
+            if (!addressInput && !autoRoom && roomOptions.length > 0 && args.allowNoRoom !== true) {
+                return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                    status: 'NEEDS_SELECTION',
+                    selectionType: 'room',
+                    message: `未指定会议室，请从 ${roomOptions.length} 个候选里选择（已按人数/常用/时段占用排序）`,
+                    options: roomOptions,
+                    recommended: roomOptions[0]?.value ?? null,
+                    hint: '选定后把 value.id 作为 address 重新调用（quick 或 prepare）；确实不需要会议室请传 allowNoRoom: true',
+                }, {
+                    warnings: [
+                        '未指定会议室：本次**没有**提交，也没有替用户挑房间。',
+                        '如需直接建会并沿用推荐，可传 autoRoom: true；不需要会议室则传 allowNoRoom: true。',
+                    ],
+                });
+            }
+            if (addressInput) {
+                // 调用方已指定（或显式 autoRoom）
+            }
+            else if (autoRoom && roomRec.best) {
+                addressInput = roomRec.best.id;
+            }
+        }
+        const conflicts = (memberConflict?.data?.conflicts ?? []);
+        if (conflicts.length > 0)
+            decisions.memberConflicts = conflicts;
+        if (free) {
+            decisions.scheduleItems = free.scheduleItems;
+            decisions.availabilityCost = free.cost;
+            if (free.slots.length > 0) {
+                decisions.suggestedSlots = free.slots;
+                decisions.slotOptions = free.slots.map((slot, index) => ({
+                    key: `T${index + 1}`,
+                    label: `${slot.begin.slice(11)}~${slot.end.slice(11)}（${day}） · 全部参会人空闲`,
+                    value: { begin: slot.begin, end: slot.end },
+                    reason: '该时段所有参会人都没有会议与日程占用（已同时核对会议回执与日程）',
+                }));
+            }
+            else if (free.blockingSummary) {
+                decisions.dayBlocked = { day, summary: free.blockingSummary };
+            }
+        }
+        decisions.timings = timings;
+        const shaped = await shapeBrowserValues(env, {
+            mt_name: args.mt_name,
+            begin_datetime: args.begin_datetime,
+            end_datetime: args.end_datetime,
+            mt_desc: args.mt_desc,
+            address: addressInput,
+            customize_address: args.customize_address,
+            hrm_members: args.hrm_members,
+            total_member: args.total_member,
+            caller: args.caller,
+            contacter: args.contacter,
+            other_remark: args.other_remark,
+            mt_type: args.mt_type,
+        });
+        const { main, mapped, unmapped } = mapFields(form.fields, shaped.values);
+        const warnings = [];
+        for (const note of shaped.notes)
+            warnings.push(note);
+        const picked = decisions.autoRoom?.picked;
+        if (picked) {
+            warnings.push(`未指定会议室 → 已自动选择「${picked.name}」（${(picked.reasons ?? []).join('；')}）；`
+                + `另有候选 ${(decisions.roomOptions ?? []).slice(1).map((item) => item.label).join(' / ') || '无'}`);
+        }
+        const slotOptions = decisions.slotOptions ?? [];
+        if (slotOptions.length > 0) {
+            warnings.push(`参会人时间有冲突；当天所有人都空的时段：${slotOptions.map((item) => `[${item.key}] ${item.label}`).join('；')}`
+                + '——请用选项方式让用户挑（选定后重新 prepare 并改时间）。');
+        }
+        else if (decisions.dayBlocked?.summary) {
+            warnings.push(String(decisions.dayBlocked.summary));
+        }
+        if (unmapped.length > 0) {
+            warnings.push(`以下字段没有在建会流程表单里找到同名字段，未自动填写：${unmapped.join('、')}`
+                + `（表单现有字段：${form.fields.map((field) => field.name).join('、')}）`);
+        }
+        if (!main[form.fields.find((field) => field.name === '会议名称')?.id ?? ''] && !mapped.mt_name) {
+            warnings.push('建会流程表单里没找到「会议名称」字段，请人工确认流程是否配错');
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'meeting.eb.meeting.create.flow.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: {
+                workflowId,
+                requestName: String(args.mt_name),
+                mtName: String(args.mt_name),
+                data: { main },
+                surfaceContinuation: form.continuation,
+            },
+            fingerprint: JSON.stringify({ workflowId, main }),
+        }, 10 * 60 * 1000);
+        return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                workflowId,
+                workflowCandidates: candidates,
+                ...(probes.length > 0 ? { workflowProbes: probes } : {}),
+                requestName: String(args.mt_name),
+                fieldMapping: mapped,
+                formData: { main },
+                formFieldCount: form.fields.length,
+                ...(Object.keys(decisions).length > 0 ? { decisions } : {}),
+            },
+            continuation,
+            expiresInSeconds: 600,
+        }, warnings.length > 0 ? { warnings } : {});
+    },
+};
+const ebMeetingCreateFlowApply = {
+    name: 'meeting.eb.meeting.create.flow.apply',
+    resource: 'eb',
+    method: 'meeting.eb.meeting.create.flow.apply',
+    action: 'meeting.eb.meeting.create.flow.apply',
+    summary: '流程建会（提交）：用确认票据提交建会流程；提交后轮询会议列表确认会议是否已生成，生成则自动出邀请函',
+    capability: 'eb.meeting',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        continuation: { type: 'string', description: 'prepare 返回的确认票据（必填）' },
+        confirm: { type: 'boolean', description: '必须显式传 true' },
+        waitSeconds: { type: 'number', description: '提交后等待会议生成的最长秒数（默认 60，0 = 不等待）' },
+    }, { required: ['continuation', 'confirm'] }),
+    handler: async (args, env) => {
+        if (args.confirm !== true) {
+            throw meetingValidationError('confirmation_required', '流程建会属于高影响写操作，必须显式传 confirm=true');
+        }
+        const lease = await env.continuation.verify(String(args.continuation ?? ''), 'meeting.eb.meeting.create.flow.apply');
+        const session = await env.host.getSession();
+        if (lease.baseUrl !== session.baseUrl || lease.userId !== session.userId) {
+            throw meetingValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+        }
+        const payload = lease?.payload ?? {};
+        const { createWorkflowHost } = await import('../../../workflow/host.js');
+        const { createWorkflowContinuationSigner } = await import('../../../workflow/continuation.js');
+        const { getWorkflowOperation } = await import('../../../workflow/operations/registry.js');
+        const wfEnv = {
+            ...workflowEnv(env),
+            host: createWorkflowHost(env.ctx),
+            continuation: createWorkflowContinuationSigner(env.ctx),
+        };
+        const submitStartedAt = Date.now();
+        const submit = getWorkflowOperation('workflow.createRequest');
+        const submitted = await submit.handler({
+            // 工作流的入参名是 context（createForm 返回的 continuation 就是它的 context 句柄）
+            context: payload.surfaceContinuation,
+            data: payload.data,
+            action: 'submit',
+            requestName: payload.requestName,
+            confirm: true,
+        }, wfEnv);
+        const submittedData = submitted?.data ?? {};
+        const requestId = String(submittedData.requestId ?? submittedData.id ?? '').trim();
+        if (!requestId && String(submittedData.status ?? '') === 'NEEDS_CONFIRMATION') {
+            // 浏览器字段（会议地点/参会人员/召集人…）解析不出唯一目标时，工作流会停下来要「确认」。
+            // 这不是失败，也不该吞掉：把服务端给的原话、已解析值、候选原样交回去，由调用方向用户确认后重提。
+            return meetingSuccess('meeting.eb.meeting.create.flow.apply', {
+                status: 'NEEDS_CONFIRMATION',
+                workflowId: payload.workflowId,
+                requestName: payload.requestName,
+                message: String(submittedData.message ?? ''),
+                resolvedValues: submittedData.resolvedValues ?? [],
+                unresolved: submittedData.unresolved ?? submittedData.candidates ?? [],
+                submit: submittedData,
+            }, {
+                warnings: [
+                    '建会流程未提交：服务端有字段无法唯一解析（多为会议地点/参会人员/召集人等浏览按钮字段），'
+                        + '请按 message / unresolved 与用户确认取值后重新 prepare（把这些字段改成服务端认得的格式，如「名称(ID)」）。',
+                ],
+            });
+        }
+        if (!requestId) {
+            // 没拿到 requestId 时**不能**说"流程已提交"：常见原因是必填项缺失（工作流只在 saveFormData 前校验），
+            // 也可能只是存了草稿。把缺失项原样交回去，让调用方补字段，而不是含糊地说"已提交"。
+            const missing = submittedData.missingFields ?? submittedData.requiredMissing ?? submittedData.missing ?? [];
+            throw meetingValidationError('flow_submit_incomplete', `建会流程未提交成功（status=${String(submittedData.status ?? submitted?.status ?? '未知')}）：`
+                + (Array.isArray(missing) && missing.length > 0
+                    ? `缺少必填项 ${missing.map((item) => item?.name ?? item).join('、')}`
+                    : '服务端未返回 requestId，请查看 result 排查'), { submit: submittedData, missing });
+        }
+        const warnings = [];
+        // 会议由流程/ESB 创建：提交后不一定立刻出现，轮询一下再决定要不要出邀请函。
+        // 默认只等 20s：流程多走审批，干等会把"建个会"拖成好几分钟（用户 2026-10-28 反馈）；
+        // 没等到就给 pending，让调用方稍后补邀请函。
+        const waitSeconds = args.waitSeconds === undefined ? 20 : Math.max(0, Math.min(180, Number(args.waitSeconds)));
+        let meetingId = '';
+        const timings = { submitMs: Date.now() - submitStartedAt };
+        if (waitSeconds > 0) {
+            // 轮询策略：**先立即查一次**（多数情况下会议是同步生成的），没有就 5 秒后再查一次；
+            // 仍未生成说明还在审批，直接返回 pending —— 不再按 waitSeconds 死等（用户体感"建会好几分钟"多半是这里）。
+            const { getMeetingOperation } = await import('../registry.js');
+            const list = getMeetingOperation('meeting.eb.meeting.list');
+            const deadline = Date.now() + Math.min(waitSeconds, 30) * 1000;
+            const pollStart = Date.now();
+            let waited = 0;
+            while (Date.now() <= deadline) {
+                try {
+                    const page = await list.handler({ mt_name: payload.mtName, pageSize: 5 }, env);
+                    const rows = (page?.data?.rows ?? []);
+                    const hit = rows
+                        .map((row) => row?.mainTable ?? row ?? {})
+                        .find((main) => String(main.mt_name ?? '').trim() === String(payload.mtName).trim());
+                    if (hit) {
+                        meetingId = String(hit.id ?? '').trim();
+                        if (meetingId)
+                            break;
+                    }
+                }
+                catch {
+                    // 查询失败不中断，继续按节奏重试
+                }
+                if (waited >= 5000)
+                    break; // 第二次仍未命中：不再等，交给调用方稍后补邀请函
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                waited += 5000;
+            }
+            timings.pollMs = Date.now() - pollStart;
+        }
+        let invitation = { pending: true };
+        if (meetingId) {
+            const invitationStart = Date.now();
+            try {
+                const { getMeetingOperation } = await import('../registry.js');
+                const render = getMeetingOperation('meeting.invitation.render');
+                const rendered = await render.handler({ mtId: meetingId }, env);
+                invitation = { pending: false, ...(rendered?.data ?? {}) };
+                timings.invitationMs = Date.now() - invitationStart;
+            }
+            catch (error) {
+                invitation = {
+                    pending: false,
+                    ok: false,
+                    error: String(error?.message ?? error).slice(0, 200),
+                };
+            }
+        }
+        else {
+            warnings.push(`流程已提交（requestId=${requestId || '未返回'}），但 ${waitSeconds}s 内没在会议表里查到「${payload.mtName}」——`
+                + '多数情况是还在审批中。审批通过后（或后台建会完成后）再跑一次 meeting.invitation.render 出邀请函；'
+                + '本 operation 不重复提交流程。');
+        }
+        return meetingSuccess('meeting.eb.meeting.create.flow.apply', {
+            status: 'COMPLETE',
+            timings,
+            workflowId: payload.workflowId,
+            requestId,
+            requestName: payload.requestName,
+            meetingId: meetingId || null,
+            invitation,
+            result: submitted?.data ?? null,
+        }, warnings.length > 0 ? { warnings } : {});
+    },
+};
+/**
+ * 一步建会（prepare + apply 合并成一次调用）。
+ *
+ * 为什么需要（2026-10-28 用户反馈「创建一个会议要好几分钟」）：
+ * CLI 单次调用其实只有 1~2 秒（prepare）/ 5 秒左右（apply），慢的是**对话里来回**——
+ * 先 prepare、再等模型确认、再 apply、中间还要补邀请函/查冲突，每轮都有模型推理与大 JSON 进出上下文。
+ * 把这两步合成一个 operation 后，无歧义情况下**一次调用就能建完**（含会议室、冲突提示、邀请函）。
+ *
+ * 仍保留人工选择：需要选流程（多流程可发起）时不提交，原样返回 NEEDS_SELECTION 的选项。
+ */
+const ebMeetingCreateFlowQuick = {
+    name: 'meeting.eb.meeting.create.flow.quick',
+    resource: 'eb',
+    method: 'meeting.eb.meeting.create.flow.quick',
+    action: 'meeting.eb.meeting.create.flow.quick',
+    summary: '一步流程建会（prepare+apply 合并）：内部并行做会议室推荐/冲突检测/空闲时段，提交后自动出邀请函；多流程或需选择时不提交，返回选项',
+    capability: 'eb.meeting',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        mt_name: { type: 'string', description: '会议名称（必填）' },
+        begin_datetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
+        end_datetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+        mt_desc: { type: 'string', description: '会议内容/说明' },
+        address: { type: 'string', description: '会议室（id 或名称；不传则返回候选让用户选，不会自动决定）' },
+        customize_address: { type: 'string', description: '自定义会议地点' },
+        hrm_members: { type: 'string', description: '参会人员 id，逗号分隔' },
+        total_member: { type: 'number', description: '参会人数' },
+        caller: { type: 'string', description: '召集人' },
+        contacter: { type: 'string', description: '联系人' },
+        other_remark: { type: 'string', description: '备注' },
+        workflowId: { type: 'string', description: '指定建会流程 id（多流程时用来跳过选择）' },
+        autoRoom: { type: 'boolean', description: '默认 false：不指定会议室时返回候选让用户选；传 true 才自动采用推荐会议室' },
+        allowNoRoom: { type: 'boolean', description: '确实不需要会议室（线上会等）时传 true' },
+        confirm: { type: 'boolean', description: '必须显式 true 才会真正提交' },
+        waitSeconds: { type: 'number', description: '提交后等待会议生成的秒数（默认 20；算法是立即查一次 + 5s 再查一次，仍未生成就返回 pending）' },
+        enrich: { type: 'boolean', description: '是否顺带做会议室推荐/冲突检测/空闲时段（默认 true；人、时间、房间都已确定时传 false 可显著加快）' },
+    }, { required: ['mt_name', 'begin_datetime', 'end_datetime', 'confirm'] }),
+    handler: async (args, env) => {
+        if (args.confirm !== true) {
+            throw meetingValidationError('confirmation_required', '一步建会会直接提交流程，必须显式传 confirm=true；如只想看方案，请用 meeting.eb.meeting.create.flow.prepare');
+        }
+        const { getMeetingOperation } = await import('../registry.js');
+        const prepareStartedAt = Date.now();
+        const prepared = await getMeetingOperation('meeting.eb.meeting.create.flow.prepare').handler({ ...args, confirm: undefined }, env);
+        if (prepared?.data?.status === 'NEEDS_SELECTION') {
+            return prepared; // 让用户先选流程，不提交
+        }
+        const continuation = String(prepared?.data?.continuation ?? '');
+        if (!continuation) {
+            throw meetingValidationError('flow_prepare_failed', '建会流程准备阶段没有返回确认票据，未提交');
+        }
+        const prepareMs = Date.now() - prepareStartedAt;
+        const applyStartedAt = Date.now();
+        const applied = await getMeetingOperation('meeting.eb.meeting.create.flow.apply').handler({
+            continuation,
+            confirm: true,
+            ...(args.waitSeconds !== undefined ? { waitSeconds: args.waitSeconds } : {}),
+        }, env);
+        const warnings = [
+            ...(prepared?.warnings ?? []),
+            ...(applied?.warnings ?? []),
+        ];
+        return meetingSuccess('meeting.eb.meeting.create.flow.quick', {
+            status: applied?.data?.status ?? 'COMPLETE',
+            workflowId: applied?.data?.workflowId,
+            requestId: applied?.data?.requestId,
+            meetingId: applied?.data?.meetingId ?? null,
+            invitation: applied?.data?.invitation ?? null,
+            decisions: prepared?.data?.preview?.decisions ?? null,
+            timings: {
+                ...(prepared?.data?.preview?.decisions?.timings ?? {}),
+                // apply 侧的分段耗时（提交/轮询/邀请函）也要带出来，否则"到底慢在哪"还是看不清
+                ...(applied?.data?.timings ?? {}),
+                prepareMs,
+                applyMs: Date.now() - applyStartedAt,
+                totalMs: Date.now() - prepareStartedAt,
+            },
+        }, warnings.length > 0 ? { warnings } : {});
+    },
+};
+export const meetingEbCreateFlowOperations = [
+    ebMeetingCreateFlowPrepare,
+    ebMeetingCreateFlowApply,
+    ebMeetingCreateFlowQuick,
+];