weaver-work-cli 0.1.31 → 0.1.33

package/dist/shortcuts/meeting/host.js

@@ -111,49 +111,42 @@ export function createMeetingHost(ctx, dependencies = {}) {
         return sessionContext;
     }
     async function download(request) {
-        const session = await ensureSession();
-        const url = new URL(request.path, session.getBaseUrl());
-        for (const [key, value] of Object.entries(request.query ?? {})) {
-            if (value !== undefined && value !== null && String(value) !== '')
-                url.searchParams.set(key, String(value));
-        }
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), request.timeoutMs ?? 60_000);
+        assertPath(request.path);
+        let response;
         try {
-            const response = await (dependencies.fetch || globalThis.fetch)(url.toString(), {
-                headers: {
-                    accept: '*/*',
-                    cookie: session.cookieHeader(),
-                    eteamsid: session.eteamsId,
-                    'user-agent': session.uaHeader(),
-                    origin: session.getBaseUrl(),
-                },
-                redirect: 'manual',
-                signal: controller.signal,
+            response = await (await runtime()).requestBinary({
+                module: 'meeting',
+                operation: 'meeting.attachment.download',
+                method: 'GET',
+                path: request.path,
+                query: omitEmptyQueryValues(request.query),
+                headers: { accept: '*/*' },
+                timeoutMs: request.timeoutMs ?? 60_000,
             });
-            if (response.status === 401 || response.status === 302) {
-                throw meetingAuthError('session_expired', '登录态已失效：下载需有效登录态，请重新登录后重试', { httpStatus: response.status });
-            }
-            if (response.status !== 200) {
-                throw new MeetingCliError('api', 'download_failed', `下载失败 HTTP ${response.status}`, {
-                    code: response.status,
-                    exitCode: 1,
-                });
-            }
-            return {
-                buffer: Buffer.from(await response.arrayBuffer()),
-                contentType: response.headers.get('content-type') ?? '',
-                contentDisposition: response.headers.get('content-disposition') ?? '',
-            };
         }
-        finally {
-            clearTimeout(timer);
+        catch (error) {
+            mapRuntimeNetworkError(error);
+        }
+        if (response.status === 401 || response.status === 302) {
+            throw meetingAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+        }
+        if (response.status !== 200) {
+            throw new MeetingCliError('api', 'download_failed', `下载失败 HTTP ${response.status}`, {
+                code: response.status,
+                exitCode: 1,
+            });
         }
+        return {
+            buffer: response.content,
+            contentType: response.contentType,
+            contentDisposition: response.headers.get('content-disposition') ?? '',
+        };
     }
     async function runtime() {
         return createE10RequestRuntime(ctx, await ensureSession(), {
             interceptors: dependencies.interceptors,
             fetch: dependencies.fetch,
+            recoverAuthentication: dependencies.recoverAuthentication,
         });
     }
     async function request(request) {

package/dist/shortcuts/meeting/operations/create.js

@@ -144,7 +144,10 @@ async function assertCreatePathAllowed(args, env) {
         throw meetingConflictError('conflict_rejected', '该租户为周期会议配置了工作流（repeatWorkFlowBaseIds 非空），周期会议必须走流程建会；CLI v1 未集成工作流发起，请通过工作流流程创建', { repeatWorkFlowBaseIds: repeatWorkflowIds });
     }
     if (!isRepeat && Number(base.onlyFlowCreate) === 1) {
-        throw meetingConflictError('conflict_rejected', '该租户 onlyFlowCreate=1：会议只能通过流程创建；CLI v1 未集成工作流发起，请通过工作流流程创建', { workFlowBaseIds: base.workFlowBaseIds ?? '' });
+        throw meetingConflictError('conflict_rejected', '该租户 onlyFlowCreate=1：会议只能通过流程创建，直连建会已被拒绝（不会写入任何数据）。'
+            + '不用停手 —— 改走 **meeting.eb.meeting.create.flow**（prepare→apply）即可：'
+            + '它会载入建会流程表单、提交审批，并在会议生成后自动出邀请函。'
+            + '如需直连建会，请管理员先在会议应用设置中关闭该开关。', { workFlowBaseIds: base.workFlowBaseIds ?? '' });
     }
 }
 /** 强制冲突检测：接口失败视为冲突（拒绝建会），cansub=false 拒绝提交。 */

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

@@ -206,6 +206,11 @@ export const EB_ENDPOINTS = [
         queryParams: ['manager', 'departmentId', 'mr_type', 'room_attr'],
         summarizeRows: summarizeRoomRows,
         summary: 'EB 版会议室列表（query_meeting_room_list + count）：自带 statusText 与状态字典',
+        emptyHint: 'EB 会议室表（`uf_mt_room_base`）查不到任何记录。可能是：① 该环境确实还没建过会议室；'
+            + '② 会议应用的「会议室列表」接口/视图未配置好（`query_meeting_room_list` 读不到数据，但表里有数据）。'
+            + '**这不代表"环境是标准版"——绝对不要改用 `meeting.room.list`**：那是标准版会议应用的会议室，'
+            + '与 EB 完全是两套数据，拿给用户就是凭空捏造房间。请如实告诉用户"EB 会议室查不到"，'
+            + '并请管理员检查会议应用的会议室配置。',
         notes: [
             '**status：`0` = 正常（可用）、`1` = 封存（不可用）** —— 不是"启用/停用"，`0` 才是正常。',
             '明细在 `data.progress.items[]`：`statusText` 已把编码翻成中文，`summary.unusable` 直接列出不可用的房间名；需要原始编码时看 `status`。',

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

@@ -91,13 +91,18 @@ export async function fetchEbAppSettings(env, operation) {
         const valid = rows.filter((row) => String(row.data_status ?? '1') === '1');
         const ordered = [...valid].sort((left, right) => (String(right.update_time ?? '').localeCompare(String(left.update_time ?? ''))));
         const base = ordered[0] ?? {};
+        // ⚠️ 管控开关必须「取严不取松」（2026-10-29 真机事故）：
+        // 生产环境库里可能有多份设置记录，其中最新一份的开关是空的、旧的一份才是 1。
+        // 此前只按最新一条取值 ⇒ 闸门被绕过，only_flow_create=1 的租户也能直连建出会议。
+        // 建会路径是**管控**而非偏好：只要任意一份有效记录开了，就必须走流程。
+        const strictest = (key) => (valid.some((row) => String(row[key] ?? '') === '1') ? '1' : String(base[key] ?? ''));
         return {
             roomChk: String(base.room_conflict_chk ?? ''),
             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 ?? ''),
+            onlyFlowCreate: strictest('only_flow_create'),
+            openMtApprove: strictest('open_mt_approve'),
             mtNewWf: String(base.mt_new_wf ?? ''),
             mtRepeatNewWf: String(base.mt_repeat_new_wf ?? ''),
             settingsRows: valid.length,
@@ -146,7 +151,14 @@ export function assertEbCreatePathAllowed(settings) {
     }
     if (blocked.length === 0)
         return;
-    throw meetingConflictError('conflict_rejected', `应用设置不允许直接建会：${blocked.join('；')}。该应用的会议必须经流程创建`
+    // 多条设置时，warnings 会随抛错一起丢掉 ⇒ 必须把「存在多份设置、按最严判定」写进错误本身，
+    // 否则排查的人只会看到"不许建会"，不知道库里有两份冲突的设置要清理。
+    const multiRow = (settings.settingsRows ?? 0) > 1
+        ? `（注意：会议应用设置存在 ${settings.settingsRows} 条有效记录，管控开关按**最严**取值 —— 任意一份开了就走流程；`
+            + `冲突策略等其余字段仍按最新一条 id=${settings.settingsId ?? '未知'}、更新于 ${settings.settingsUpdatedAt || '未知'} 判断。`
+            + '建议让管理员在系统页面清理重复的设置记录。）'
+        : '';
+    throw meetingConflictError('conflict_rejected', `应用设置不允许直接建会：${blocked.join('；')}。${multiRow}该应用的会议必须经流程创建`
         + `（新建会议工作流 mt_new_wf=${settings.mtNewWf || '未配置'}，周期会议工作流 mt_repeat_new_wf=${settings.mtRepeatNewWf || '未配置'}）——`
         + 'CLI 不直接建会、也不代替流程建会（否则会产生流程之外、request_id 为空的会议，且与流程/ESB 自动建会重复）。'
         + '这属于应用管控，CLI 不会绕过 —— 但也不用停手：改走 **meeting.eb.meeting.create.flow**'
@@ -156,6 +168,9 @@ export function assertEbCreatePathAllowed(settings) {
         openMtApprove: settings.openMtApprove,
         mtNewWf: settings.mtNewWf,
         mtRepeatNewWf: settings.mtRepeatNewWf,
+        settingsRows: settings.settingsRows ?? 0,
+        settingsId: settings.settingsId ?? '',
+        settingsUpdatedAt: settings.settingsUpdatedAt ?? '',
     });
 }
 /** 会议室冲突：查占用视图（query_roomusage_list），时间重叠即冲突。 */
@@ -354,7 +369,42 @@ export const ebMeetingWritePreflight = async ({ endpoint, payload, args, env, ex
     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;
+    // ⛔ 参会人必须是**员工 id**，不能是姓名（2026-10-29 真机事故）：
+    // 传姓名时会议主表能写进去（hrm_members 是文本渲染字段），但
+    //   ① 回执/签到按 id 建 → 建不起来，参会人收不到邀请；
+    //   ② 人员冲突检测按 id 比对 → 一个都查不到，等于冲突检测被静默跳过。
+    // 所以在这里把姓名解析成 id 再往下走，解析不出来的明确列出来，不静默丢。
+    const memberWarnings = [];
+    const rawMembers = typeof main.hrm_members === 'string' ? main.hrm_members.trim() : '';
+    if (rawMembers) {
+        const items = rawMembers.split(/[,;，；]+/u).map((item) => item.trim()).filter((item) => item !== '');
+        const nameLike = items.filter((item) => !/^\d+$/u.test(item));
+        if (nameLike.length > 0) {
+            const { resolveMemberIdsByName } = await import('./schedule.js');
+            const idsByName = await resolveMemberIdsByName(env, nameLike);
+            const resolved = items.map((item) => idsByName.get(item) ?? item);
+            payload.mainTable.hrm_members = [...new Set(resolved)].join(',');
+            const unresolved = nameLike.filter((name) => !idsByName.has(name));
+            if (unresolved.length > 0) {
+                memberWarnings.push(`参会人中有 ${unresolved.length} 位未能解析为员工 id：${unresolved.join('、')}`
+                    + ' —— 已按原名写入。**这几位的回执与签到建不起来，且不会参与人员冲突检测**，请核对姓名或改用员工 id。');
+            }
+            const resolvedNames = nameLike.filter((name) => idsByName.has(name));
+            if (resolvedNames.length > 0) {
+                memberWarnings.push(`参会人已由姓名解析为员工 id：${resolvedNames.join('、')}`);
+            }
+        }
+    }
+    // 冲突检测只认数字 id（`toIdCsv` 会硬校验）：解析不出 id 的那几位仍然留在主表里（不静默丢人），
+    // 但不参与人员冲突检测 —— 否则一个姓名就会让整场建会直接 id_invalid 失败。
+    const memberItems = String(main.hrm_members ?? '').split(/[,;，；]+/u).map((item) => item.trim()).filter((item) => item !== '');
+    const numericMembers = memberItems.filter((item) => /^\d+$/u.test(item));
+    if (memberItems.length > numericMembers.length) {
+        const skipped = memberItems.filter((item) => !/^\d+$/u.test(item));
+        memberWarnings.push(`参会人 ${skipped.join('、')} 不是员工 id，**不参与本次人员冲突检测**`
+            + '（这几位的回执与签到也建不起来）——请用员工 id 或可唯一匹配的姓名重新提交。');
+    }
+    const hrmMembers = numericMembers.length > 0 ? numericMembers.join(',') : undefined;
     // 建会必读应用设置（闸门）；变更只在确有冲突检测目标时才读（避免多一次请求）。
     const settings = isCreate || address || hrmMembers ? await fetchEbAppSettings(env, operation) : undefined;
     const preflightWarnings = [];
@@ -367,10 +417,11 @@ export const ebMeetingWritePreflight = async ({ endpoint, payload, args, env, ex
                 + '如需以另一条为准，请先在系统页面清理重复的设置记录。');
         }
     }
+    const head = [...preflightWarnings, ...memberWarnings];
     if (!begin || !end)
-        return preflightWarnings;
+        return head;
     if (!address && !hrmMembers)
-        return preflightWarnings;
+        return head;
     const outcome = await runEbConflictCheck({
         beginDatetime: begin,
         endDatetime: end,
@@ -424,8 +475,28 @@ export const ebMeetingWritePreflight = async ({ endpoint, payload, args, env, ex
                 extraWarnings.push(`共同空闲时段计算失败（${String(error?.message ?? error).slice(0, 80)}），请手动换时间`);
             }
         }
+        // ⛔ 冲突必须**拦下来让用户拍板**，不能只在 warnings 里提一句就放行
+        // （2026-10-29 真机事故：CLI 返回 ok + continuation，智能体直接提交了，
+        //   用户事后才发现和已有会议撞了 2 小时 —— 冲突提示等于没有）。
+        if (args.conflictAck !== true) {
+            const detail = outcome.member.conflicts
+                .map((item) => `${item.conflictedMembers.join('、')} 在 ${item.begin}~${item.end} 已有「${item.name}」`)
+                .join('；');
+            const slots = extras.slotOptions ?? [];
+            const slotText = slots.length > 0
+                ? `当天所有人都有空的时段：${slots.map((item) => `[${item.key}] ${item.label}`).join('；')}`
+                : (extras.dayBlocked ? String(extras.dayBlocked.summary ?? '当天已排满') : '当天没有全员空闲时段');
+            throw meetingConflictError('conflict_rejected', `参会人时间冲突，**未写入任何数据**：${detail}。${slotText}。`
+                + '请用**选项方式**让用户确认：改到上面的候选时段，或明确接受冲突'
+                + '（确认后带 conflictAck=true 重新提交，届时才会真正写入）。', {
+                conflicts: outcome.member.conflicts,
+                slotOptions: extras.slotOptions ?? [],
+                suggestedSlots: extras.suggestedSlots ?? [],
+                dayBlocked: extras.dayBlocked ?? null,
+            });
+        }
     }
-    return [...preflightWarnings, ...outcome.warnings, ...extraWarnings];
+    return [...preflightWarnings, ...memberWarnings, ...outcome.warnings, ...extraWarnings];
 };
 /** 只查不建：会议室冲突检测 operation。 */
 const ebConflictRoom = {

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

@@ -168,7 +168,7 @@ async function shapeBrowserValues(env, values) {
     return { values: shaped, notes };
 }
 /** 按别名把会议字段映射到表单字段 id。 */
-function mapFields(fields, values) {
+export function mapFields(fields, values) {
     const byName = new Map(fields.map((field) => [field.name.trim(), field]));
     const main = {};
     const mapped = {};
@@ -176,7 +176,9 @@ function mapFields(fields, values) {
     for (const [key, raw] of Object.entries(values)) {
         if (raw === undefined || raw === null || raw === '')
             continue;
-        const aliases = FIELD_ALIASES[key] ?? [];
+        // 2026-10-28：租户自建字段不在别名表里 —— 此时按调用方给的**字段名原文**精确匹配，
+        // 这样 extraFields 能填流程表单上的任何字段（参会客户/联系方式之类），而不是只能填内置的十来个。
+        const aliases = FIELD_ALIASES[key] ?? [key];
         const hit = aliases.map((name) => byName.get(name)).find((field) => field !== undefined);
         if (!hit) {
             unmapped.push(key);
@@ -187,11 +189,43 @@ function mapFields(fields, values) {
     }
     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] };
+/**
+ * 把 `workflowId` 入参规整成 id 列表。
+ *
+ * ⛔ 2026-10-29 回归修复：此前直接 `String(args.workflowId)` —— 传数组会被拼成 `"a,b"`，
+ * 当成**单个** id 塞给下游 `workflow.createForm`，而 workflow 模块对多值只取第一个能载入的、
+ * 并回 `selectionSource: workflowId`，表面像"传了两个"，实际是 CLI 替用户指定了第一个。
+ * 现在单值 / 数组 / 逗号分隔 / 「名称(id)」写法统一解析成列表，多个就交给选择流程。
+ */
+export function normalizeWorkflowIds(raw) {
+    if (raw === undefined || raw === null)
+        return [];
+    const list = Array.isArray(raw) ? raw : [raw];
+    const ids = [];
+    for (const item of list) {
+        for (const piece of String(item ?? '').split(/[,;，；\s]+/)) {
+            const term = piece.trim();
+            if (!term)
+                continue;
+            const matched = term.match(/[(（](\d{6,})[)）]$/);
+            const id = matched ? matched[1] : term;
+            if (!ids.includes(id))
+                ids.push(id);
+        }
+    }
+    return ids;
+}
+/** 解析要用的建会流程 id：入参优先（可多个），其次取应用设置里的 mt_new_wf。 */
+export async function resolveWorkflowId(env, args) {
+    const explicitList = normalizeWorkflowIds(args.workflowId);
+    if (explicitList.length > 0) {
+        // 显式传多个同样**不替用户拍板**：与「应用设置配了多个」走同一套探测 + 选择逻辑。
+        return {
+            workflowId: explicitList.length === 1 ? explicitList[0] : '',
+            candidates: explicitList,
+            source: 'argument',
+        };
+    }
     const settings = await fetchEbAppSettings(env, 'meeting.eb.meeting.create.flow.prepare');
     const candidates = String(settings.mtNewWf ?? '')
         .split(/[,;，；\s]+/)
@@ -201,7 +235,7 @@ async function resolveWorkflowId(env, args) {
         throw meetingValidationError('flow_not_configured', '应用设置里没有配置「新建会议工作流」（mt_new_wf 为空），无法走流程建会；请管理员在会议应用设置里配置，或关闭「只允许通过流程新建会议」');
     }
     // 多个流程时先不拍板：由调用方探测"当前人员对每个流程有没有发起权限"，再决定是否让用户选。
-    return { workflowId: candidates.length === 1 ? candidates[0] : '', candidates };
+    return { workflowId: candidates.length === 1 ? candidates[0] : '', candidates, source: 'settings' };
 }
 const ebMeetingCreateFlowPrepare = {
     name: 'meeting.eb.meeting.create.flow.prepare',
@@ -224,19 +258,33 @@ const ebMeetingCreateFlowPrepare = {
         caller: { type: 'string', description: '召集人' },
         contacter: { type: 'string', description: '联系人' },
         other_remark: { type: 'string', description: '备注' },
-        workflowId: { type: 'string', description: '指定建会流程 id（默认取应用设置 mt_new_wf 的第一个）' },
+        workflowId: {
+            oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+            description: '指定建会流程 id：单个 id、id 数组或逗号分隔都可以，也接受「流程名(123456)」写法。'
+                + '**传多个时 CLI 同样不会替你选**——会逐个探测可发起性，多个可用则返回 NEEDS_SELECTION 让用户挑；'
+                + '不传则用应用设置 mt_new_wf 配置的流程（配了多个时同样让用户选）',
+        },
         autoRoom: { type: 'boolean', description: '默认 false：未指定会议室时返回候选让用户选；传 true 才自动采用推荐' },
         allowNoRoom: { type: 'boolean', description: '确实不需要会议室（线上会等）时传 true，避免被“请选择会议室”拦住' },
+        extraFields: {
+            type: 'object',
+            description: '按**流程表单里的字段名**填额外字段，形如 {"参会客户": "xx公司", "联系方式": "138xxxx"}'
+                + '：用于租户在流程表单上自建、CLI 内置别名里没有的字段。键必须与该流程表单的字段名完全一致'
+                + '（prepare 的 warnings 会列出表单现有全部字段名）；匹配不到的会进 unmapped 提示，不会瞎填',
+        },
     }, { 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 sourceLabel = resolved.source === 'argument' ? '调用方传入' : '应用设置配置';
         const probes = [];
         const loadedForms = new Map();
         if (!workflowId && candidates.length > 1) {
-            // 应用设置里配了多个建会流程：**逐个探测当前人员能否发起**（createForm 能载入 = 有发起权限），
-            // 不能默认拿第一个就提交 —— 用户可能对第一个没有发起权限（2026-10-28 用户要求）。
+            // 有多个建会流程候选（应用设置配了多个，或入参传了多个 id）：**逐个探测当前人员能否发起**
+            // （createForm 能载入 = 有发起权限），不能默认拿第一个就提交 —— 用户可能对第一个没有发起权限，
+            // 也可能各流程表单字段完全不同（2026-10-28 / 2026-10-29 用户两次要求）。
             // 并行探测：每个流程一次 createForm（内含多次 OA 请求），串行会成倍放大等待
             const probed = await Promise.all(candidates.map(async (id) => {
                 try {
@@ -270,25 +318,30 @@ const ebMeetingCreateFlowPrepare = {
             }
             const launchable = probes.filter((probe) => probe.launchable);
             if (launchable.length === 0) {
-                throw meetingValidationError('flow_not_launchable', `应用设置配置了 ${candidates.length} 个建会流程，但当前账号一个都发起不了（无发起权限或流程已停用）：`
+                throw meetingValidationError('flow_not_launchable', `${sourceLabel}了 ${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} 个建会流程，请让用户选择要触发哪一个`,
+                    message: `${sourceLabel}了 ${candidates.length} 个建会流程，当前账号可发起其中 ${launchable.length} 个，`
+                        + '请让用户选择要触发哪一个 —— **不要默认取第一个**（各流程表单字段可能完全不同，选错会漏字段；'
+                        + '2026-10-29 真实事故：取第一个导致字段全填不进另一条流程，用户以为"系统只支持一条流程"）',
                     options: launchable.map((probe, index) => ({
                         key: `W${index + 1}`,
                         label: probe.name ? `${probe.name}（${probe.workflowId}）` : probe.workflowId,
                         value: { workflowId: probe.workflowId },
                         reason: '当前账号有发起权限',
+                        // 把该流程的字段名如实带出来：不同流程字段差异很大（有的有设备需求/涉密项目，有的没有），
+                        // 用户要靠这个才能选对（2026-10-29 用户反馈：选错方式后字段全填不进去）。
+                        fields: (loadedForms.get(probe.workflowId)?.fields ?? []).map((f) => f.name).filter(Boolean),
                     })),
                     probes,
                 }, {
                     warnings: [
-                        `检测到 ${candidates.length} 个建会流程，其中 ${launchable.length} 个当前账号可发起；`
-                            + '请把这几个流程做成选项让用户挑一个，选定后带 workflowId 重新 prepare。',
+                        `${sourceLabel}了 ${candidates.length} 个建会流程，其中 ${launchable.length} 个当前账号可发起；`
+                            + '**必须把这几个流程做成选项让用户挑一个，禁止自己替用户选**；选定后带单个 workflowId 重新 prepare。',
                         ...probes.filter((probe) => !probe.launchable)
                             .map((probe) => `流程 ${probe.workflowId} 当前账号无法发起（${probe.reason ?? '无权限'}），已排除`),
                     ],
@@ -314,13 +367,17 @@ const ebMeetingCreateFlowPrepare = {
             .map((item) => item.trim())
             .filter((item) => item !== '');
         let addressInput = args.address;
+        // 记录"用户有没有自己指定会议室"：后面决定文案是"按你的指定"还是"自动选择"。
+        const hadAddressInput = String(args.address ?? '').trim() !== '';
         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)
+        // 推荐照常跑：**即使调用方指定了会议室**也要跑 —— 一来说明"你指定的那间是否被占用"，
+        // 二来冲突时能立刻给出替代候选（2026-10-29 用户明确要求：指定了也要判冲突、冲突了要推荐）。
+        const roomTask = (enrich && beginText && endText)
             ? recommendRooms(env, {
                 beginDatetime: beginText,
                 endDatetime: endText,
@@ -328,6 +385,16 @@ const ebMeetingCreateFlowPrepare = {
                 topN: 3,
             }).catch(() => null)
             : Promise.resolve(null);
+        // ⛔ 指定了会议室时，**单独查它在该时段是否已被占用**（query_roomusage_list）。
+        // 以前 `!addressInput` 直接跳过整段 → "指定了一间被占用的房"照样往下走，用户到页面上才发现。
+        const addressId = String(addressInput ?? '').trim();
+        const addressIsRoomId = /^\d+$/.test(addressId);
+        const roomConflictTask = (enrich && beginText && endText && addressIsRoomId)
+            ? (async () => {
+                const { getMeetingOperation } = await import('../registry.js');
+                return getMeetingOperation('meeting.eb.conflict.room').handler({ beginDatetime: beginText, endDatetime: endText, address: addressId }, env);
+            })().catch(() => null)
+            : Promise.resolve(null);
         const conflictTask = (enrich && beginText && endText && memberIds.length > 0)
             ? (async () => {
                 const { getMeetingOperation } = await import('../registry.js');
@@ -345,16 +412,49 @@ const ebMeetingCreateFlowPrepare = {
                 includeSchedule: true,
             }).catch(() => null)
             : Promise.resolve(null);
-        const [roomRec, memberConflict, free] = await Promise.all([roomTask, conflictTask, availabilityTask]);
+        const [roomRec, memberConflict, free, roomConflict] = await Promise.all([
+            roomTask, conflictTask, availabilityTask, roomConflictTask,
+        ]);
         timings.parallelMs = Date.now() - startedAt;
+        // 会议室候选（指定/未指定都用这一份）：冲突时直接拿它当替代方案。
+        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('；'),
+        }));
+        // ① 指定的会议室该时段已被占用 → 不替用户改，但必须拦下来并给替代候选。
+        const roomConflictData = roomConflict?.data;
+        if (addressInput && roomConflictData?.hasConflict === true) {
+            const busy = Array.isArray(roomConflictData.conflicts) ? roomConflictData.conflicts : [];
+            decisions.roomConflict = {
+                address: addressId,
+                hasConflict: true,
+                conflicts: busy,
+                verdict: roomConflictData.verdict ?? 'conflict',
+            };
+            if (roomOptions.length > 0)
+                decisions.roomOptions = roomOptions;
+            return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                status: 'NEEDS_SELECTION',
+                selectionType: 'room_conflict',
+                message: `你指定的会议室在 ${beginText}~${endText} 已被占用（${busy.length} 条占用记录），`
+                    + '本次**没有提交**。请改用下面空闲的会议室，或调整会议时间',
+                options: roomOptions,
+                recommended: roomOptions[0]?.value ?? null,
+                conflicts: busy,
+                hint: '选定后把 value.id 作为 address 重新调用；要改时间就同时传新的 begin_datetime/end_datetime',
+            }, {
+                warnings: [
+                    `会议室 ${addressId} 在该时段已有 ${busy.length} 条占用，已拦下未提交。`,
+                    roomOptions.length > 0
+                        ? `已按人数/常用/空闲给出 ${roomOptions.length} 个替代会议室（R1 为首选）。`
+                        : '该时段没有可替代的空闲会议室，建议调整会议时间或改线上会议（allowNoRoom: true）。',
+                ],
+            });
+        }
         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
@@ -388,6 +488,34 @@ const ebMeetingCreateFlowPrepare = {
                 addressInput = roomRec.best.id;
             }
         }
+        // ② 没指定会议室、也没允许无房间，且一个候选都给不出来 → **必须拦住**。
+        // 否则表单里「会议地点」留空、流程照样提交，用户拿到的是"没有会议室"的会（2026-10-29 用户要求：
+        // 没填会议室就得先按规则推荐空闲的，推荐不出来也要说清楚，不能静默留空）。
+        if (enrich && !addressInput && args.allowNoRoom !== true) {
+            decisions.roomUnavailable = {
+                reason: roomRec
+                    ? `该时段没有满足条件的空闲会议室（共 ${roomRec.meta?.roomsTotal ?? 0} 间，可用 ${roomRec.meta?.roomsUsable ?? 0} 间，被占用 ${roomRec.meta?.roomsBusy ?? 0} 间）`
+                    : '会议室推荐没有返回结果（会议室列表接口读不到，或推荐过程出错）',
+                meta: roomRec?.meta ?? null,
+            };
+            return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                status: 'NEEDS_SELECTION',
+                selectionType: 'room_unavailable',
+                message: '未指定会议室，且按人数/时段没能推荐出可用的空闲会议室。'
+                    + '请让用户从下面三条里选一条，**不要**直接提交一个没有地点的会议',
+                options: [
+                    { key: 'C1', label: '我指定具体会议室（表单里点选，或告诉我会议室名称/id）', value: { action: 'specify' } },
+                    { key: 'C2', label: '改用线上会议（腾讯会议/视频）', value: { action: 'no_room' } },
+                    { key: 'C3', label: '先按"地点待定"提交', value: { action: 'allow_no_room' } },
+                ],
+                roomUnavailable: decisions.roomUnavailable,
+            }, {
+                warnings: [
+                    `会议室推荐无结果：${String(decisions.roomUnavailable.reason)}。本次**没有提交**。`,
+                    '确实不需要会议室（线上会）就带 allowNoRoom: true 重新调用；要指定房间就带 address。',
+                ],
+            });
+        }
         const conflicts = (memberConflict?.data?.conflicts ?? []);
         if (conflicts.length > 0)
             decisions.memberConflicts = conflicts;
@@ -421,13 +549,20 @@ const ebMeetingCreateFlowPrepare = {
             contacter: args.contacter,
             other_remark: args.other_remark,
             mt_type: args.mt_type,
+            ...(args.extraFields && typeof args.extraFields === 'object' && !Array.isArray(args.extraFields)
+                ? args.extraFields
+                : {}),
         });
         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) {
+        // ⚠️ 只在"用户没指定会议室、由 CLI 自动选"时才说这句。
+        // 以前无条件输出"未指定会议室 → 已自动选择"，用户明明传了 address 也被这么讲（2026-10-29 真机踩到）；
+        // 而 picked 是**推荐排序第一**，未必等于用户指定的那间，说错会直接误导。
+        // 指定会议室时不再另加提示 —— `shaped.notes` 里已有"会议地点按浏览按钮格式提交：<名称>(<id>)"。
+        if (picked && !hadAddressInput) {
             warnings.push(`未指定会议室 → 已自动选择「${picked.name}」（${(picked.reasons ?? []).join('；')}）；`
                 + `另有候选 ${(decisions.roomOptions ?? []).slice(1).map((item) => item.label).join(' / ') || '无'}`);
         }
@@ -653,12 +788,19 @@ const ebMeetingCreateFlowQuick = {
         caller: { type: 'string', description: '召集人' },
         contacter: { type: 'string', description: '联系人' },
         other_remark: { type: 'string', description: '备注' },
-        workflowId: { type: 'string', description: '指定建会流程 id（多流程时用来跳过选择）' },
+        workflowId: {
+            oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+            description: '指定建会流程 id（单个 / 数组 / 逗号分隔）。传多个时不会替你选：会返回 NEEDS_SELECTION 让用户挑',
+        },
         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 可显著加快）' },
+        extraFields: {
+            type: 'object',
+            description: '按流程表单字段名填额外字段（租户自建字段用这个口子带进去），形如 {"参会客户": "xx公司"}',
+        },
     }, { required: ['mt_name', 'begin_datetime', 'end_datetime', 'confirm'] }),
     handler: async (args, env) => {
         if (args.confirm !== true) {