weaver-work-cli 0.1.33 → 0.1.36

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

@@ -1,7 +1,11 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
 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';
+import { loadRooms, recommendRooms } from './room-recommend.js';
 /**
  * 通过**流程**新建 EB 会议（`meeting.eb.meeting.create.flow`）。
  *
@@ -132,12 +136,17 @@ async function resolveRoomValue(env, input) {
 async function shapeBrowserValues(env, values) {
     const notes = [];
     const shaped = { ...values };
+    const readable = {};
     if (shaped.address !== undefined && shaped.address !== '') {
         const room = await resolveRoomValue(env, String(shaped.address));
         if (room) {
             shaped.address = room;
+            readable.address = room.name;
             notes.push(`会议地点按浏览按钮格式提交：${room.name}(${room.id})`);
         }
+        else {
+            readable.address = String(shaped.address);
+        }
     }
     const personFields = ['hrm_members', 'caller', 'contacter'];
     const idPool = [];
@@ -151,43 +160,150 @@ async function shapeBrowserValues(env, values) {
     if (idPool.length > 0) {
         const names = await resolveEmployeeNames(env, idPool);
         const toObject = (id) => ({ id, name: names.get(id) ?? id });
+        const toName = (id) => 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);
+            readable.hrm_members = ids.map(toName).join('、');
             notes.push(`参会人员按浏览按钮格式提交：${ids.length} 人`);
         }
         if (shaped.caller !== undefined && shaped.caller !== '') {
             const id = String(shaped.caller).trim();
             shaped.caller = toObject(id);
+            readable.caller = toName(id);
         }
         if (shaped.contacter !== undefined && shaped.contacter !== '') {
             const id = String(shaped.contacter).trim();
             shaped.contacter = toObject(id);
+            readable.contacter = toName(id);
         }
     }
-    return { values: shaped, notes };
+    // 其余标量字段（会议名称/开始时间/结束时间/会议内容/人数…）原样给邀请函用
+    for (const [key, raw] of Object.entries(values)) {
+        if (readable[key] !== undefined)
+            continue;
+        if (raw === undefined || raw === null || raw === '')
+            continue;
+        if (typeof raw === 'object')
+            continue;
+        readable[key] = String(raw);
+    }
+    return { values: shaped, notes, readable };
+}
+/** 去掉字段名里的括号提示语并压掉空白：「开始时间(具体开始时间)」→「开始时间」。 */
+function normalizeFieldName(name) {
+    return String(name ?? '')
+        .replace(/[（(][^（()）]*[）)]/g, '')
+        .replace(/[\s\u3000]+/g, '')
+        .trim();
 }
-/** 按别名把会议字段映射到表单字段 id。 */
-export function mapFields(fields, values) {
+/**
+ * 按别名把会议字段映射到表单字段 **datakey**（fieldId）。
+ *
+ * @param preferred 上次解析出的「语义键 → datakey」。命中即直接用，**不再看中文名** ——
+ *   表单字段改名、或别名表没覆盖到（如「会议名称(请填写会议的具体名称)」这类带提示语的）也能填对。
+ */
+export function mapFields(fields, values, preferred = {}) {
     const byName = new Map(fields.map((field) => [field.name.trim(), field]));
+    const byId = new Map(fields.map((field) => [field.id, field]));
+    // 归一化索引：去掉字段名里的括号提示语（「开始时间(具体开始时间)」→「开始时间」）。
+    // ⛔ 2026-10-30 真机踩到：NEW 建会流程的字段名全带提示语，按原名精确匹配会**全部落空** ——
+    // 表现为「会议名称/开始时间/结束时间都没填进去」，而 prepare 仍然显示成功。
+    const byNormalized = new Map();
+    for (const field of fields) {
+        const key = normalizeFieldName(field.name);
+        if (key && !byNormalized.has(key))
+            byNormalized.set(key, field);
+    }
     const main = {};
     const mapped = {};
     const unmapped = [];
+    const resolved = {};
+    const findField = (aliases) => {
+        // ① 原名精确
+        for (const name of aliases) {
+            const field = byName.get(name);
+            if (field)
+                return field;
+        }
+        // ② 去掉括号提示语后精确
+        for (const name of aliases) {
+            const field = byNormalized.get(normalizeFieldName(name));
+            if (field)
+                return field;
+        }
+        // ③ 归一化后包含（兜住「会议名称(请填写…)」之外的变体，如「会议主题名称」）
+        for (const name of aliases) {
+            const needle = normalizeFieldName(name);
+            if (needle.length < 2)
+                continue;
+            for (const [key, field] of byNormalized) {
+                if (key.includes(needle))
+                    return field;
+            }
+        }
+        return undefined;
+    };
     for (const [key, raw] of Object.entries(values)) {
         if (raw === undefined || raw === null || raw === '')
             continue;
+        // ① 先用固化的 datakey（字段改名也不受影响）；② 没有再按中文名别名匹配。
         // 2026-10-28：租户自建字段不在别名表里 —— 此时按调用方给的**字段名原文**精确匹配，
         // 这样 extraFields 能填流程表单上的任何字段（参会客户/联系方式之类），而不是只能填内置的十来个。
         const aliases = FIELD_ALIASES[key] ?? [key];
-        const hit = aliases.map((name) => byName.get(name)).find((field) => field !== undefined);
+        const prefId = preferred[key];
+        const hit = (prefId ? byId.get(prefId) : undefined) ?? findField(aliases);
         if (!hit) {
             unmapped.push(key);
             continue;
         }
         main[hit.id] = raw;
         mapped[key] = `${hit.name}(${hit.id})`;
+        resolved[key] = hit.id;
+    }
+    return { main, mapped, unmapped, resolved };
+}
+function flowFieldCacheDir(env) {
+    const configured = env?.ctx?.config?.path?.();
+    const root = configured
+        ? resolve(String(configured), '..')
+        : (process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli'));
+    return resolve(root, 'meeting', 'cache');
+}
+function flowFieldCacheFile(env, workflowId) {
+    return resolve(flowFieldCacheDir(env), `flow-fields-${workflowId}.json`);
+}
+/** 读固化映射；读不到/损坏都返回空对象（不阻断建会）。 */
+export async function readFlowFieldMap(env, workflowId) {
+    try {
+        const file = flowFieldCacheFile(env, workflowId);
+        if (!existsSync(file))
+            return {};
+        const parsed = JSON.parse(await readFile(file, 'utf8'));
+        return parsed && typeof parsed.mapping === 'object' && parsed.mapping ? parsed.mapping : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** 写固化映射；失败只影响"下次还要按名字猜"，不影响本次结果，故吞掉异常。 */
+async function writeFlowFieldMap(env, workflowId, workflowName, mapping) {
+    if (Object.keys(mapping).length === 0)
+        return;
+    try {
+        const file = flowFieldCacheFile(env, workflowId);
+        await mkdir(resolve(file, '..'), { recursive: true });
+        const cache = {
+            workflowId,
+            ...(workflowName ? { workflowName } : {}),
+            savedAt: new Date().toISOString(),
+            mapping,
+        };
+        await writeFile(file, JSON.stringify(cache, null, 2), 'utf8');
+    }
+    catch {
+        /* 缓存写失败不阻断 */
     }
-    return { main, mapped, unmapped };
 }
 /**
  * 把 `workflowId` 入参规整成 id 列表。
@@ -215,7 +331,85 @@ export function normalizeWorkflowIds(raw) {
     }
     return ids;
 }
-/** 解析要用的建会流程 id：入参优先（可多个），其次取应用设置里的 mt_new_wf。 */
+/**
+ * 自用固化：建会流程 id 列表，**顺序即优先级**（第一个当前账号能发起的直接就用）。
+ *
+ * 为什么固化（2026-10-30 用户明确要求）：自用场景就固定这两条建会流程，不必每次都把
+ * "选流程"这道选择题抛给用户 —— 每次打断一轮对话，且选错流程会导致字段填不进另一条
+ * （2026-10-29 真实事故）。流程 id 写在这里而不是读应用设置，顺带省掉一次设置查询。
+ *
+ * 关闭/覆盖：
+ * - `WEAVER_MEETING_FIXED_FLOW=0` → 关掉固化，退回"读应用设置 mt_new_wf + 让用户选"的通用行为；
+ * - `WEAVER_MEETING_FIXED_FLOW_IDS=<id1,id2>` → 换一组默认流程（切租户/环境时用）。
+ *
+ * ⛔ 固化不等于"不校验权限"：仍然逐个探测"当前账号能不能发起"，全部发起不了才回退应用设置。
+ */
+const FIXED_FLOW_IDS = ['1325677244111462606', '1326190634427154474'];
+const FIXED_FLOW_PROFILES = [
+    {
+        host: 'www.e-cology.com.cn',
+        tenantKey: 't7akvdnf84',
+        label: '泛微生产（泛微网络）',
+        ids: [...FIXED_FLOW_IDS],
+    },
+];
+function fixedFlowFlagOn() {
+    const flag = String(process.env.WEAVER_MEETING_FIXED_FLOW ?? '1').trim().toLowerCase();
+    return !(flag === '0' || flag === 'false' || flag === 'off');
+}
+function fixedFlowOverride() {
+    const override = String(process.env.WEAVER_MEETING_FIXED_FLOW_IDS ?? '').trim();
+    if (!override)
+        return [];
+    return override.split(/[,;，；\s]+/).map((item) => item.trim()).filter((item) => item !== '');
+}
+/** 无环境的固化列表（也供单测）：环境变量覆盖 > 内置默认。 */
+export function fixedFlowIds() {
+    if (!fixedFlowFlagOn())
+        return [];
+    const override = fixedFlowOverride();
+    return override.length > 0 ? override : [...FIXED_FLOW_IDS];
+}
+/**
+ * 按当前登录环境挑固化流程：host 必须命中配置（租户可取到才对租户，取不到只比 host）。
+ * 命中不了 → 返回空，表示"这个环境不启用固化"，交回应用设置/入参决定。
+ */
+export async function fixedFlowIdsForEnv(env) {
+    if (!fixedFlowFlagOn())
+        return { ids: [] };
+    const override = fixedFlowOverride();
+    if (override.length > 0)
+        return { ids: override, label: '环境变量指定' };
+    let baseUrl = '';
+    let tenantKey = '';
+    try {
+        const session = await env?.host?.getSession?.();
+        baseUrl = String(session?.baseUrl ?? '');
+        tenantKey = String(session?.tenantKey ?? session?.tenantId ?? '');
+    }
+    catch {
+        /* 取不到登录环境（离线/单测）→ 按默认配置走 */
+    }
+    if (!baseUrl)
+        return { ids: [...FIXED_FLOW_IDS], label: '默认固化配置（未取到登录环境）' };
+    const host = baseUrl.replace(/^https?:\/\//i, '').replace(/\/.*$/, '').toLowerCase();
+    const hit = FIXED_FLOW_PROFILES.find((profile) => profile.host === host
+        && (!profile.tenantKey || !tenantKey || profile.tenantKey === tenantKey));
+    return hit ? { ids: [...hit.ids], label: hit.label } : { ids: [] };
+}
+/**
+ * 多流程都能发起时，是否自动取第一个。
+ *
+ * ⛔ **默认不自动**（2026-10-30 用户明确纠正）：候选流程**都有发起权限 → 弹窗让用户选**；
+ * 只有一个有权限 → 直接发起（不弹窗）；都没有权限 → 报"没有发起权限"。
+ * 只有显式 `flowChoice: 'auto'`（或 `WEAVER_MEETING_FLOW_CHOICE=auto`）才自动取第一个。
+ */
+export function shouldAutoPickFlow(args) {
+    if (args.flowChoice === 'auto')
+        return true;
+    return String(process.env.WEAVER_MEETING_FLOW_CHOICE ?? '').trim().toLowerCase() === 'auto';
+}
+/** 解析要用的建会流程 id：入参优先（可多个），其次固化列表，最后才是应用设置里的 mt_new_wf。 */
 export async function resolveWorkflowId(env, args) {
     const explicitList = normalizeWorkflowIds(args.workflowId);
     if (explicitList.length > 0) {
@@ -226,30 +420,102 @@ export async function resolveWorkflowId(env, args) {
             source: 'argument',
         };
     }
+    // 固化优先（2026-10-30）：自用固定流程，省一次设置查询，也不受 mt_new_wf 配置影响。
+    // 只有登录环境命中固化配置才启用（避免拿生产的流程 id 去撞测试环境）。
+    const fixed = await fixedFlowIdsForEnv(env);
+    if (fixed.ids.length > 0) {
+        return {
+            workflowId: fixed.ids.length === 1 ? fixed.ids[0] : '',
+            candidates: fixed.ids,
+            source: 'fixed',
+            ...(fixed.label ? { label: fixed.label } : {}),
+        };
+    }
     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 为空），无法走流程建会；请管理员在会议应用设置里配置，或关闭「只允许通过流程新建会议」');
+        throw meetingValidationError('flow_not_configured', '应用设置里没有配置「新建会议工作流」（mt_new_wf 为空），也没有启用固化流程，无法走流程建会；'
+            + '请管理员在会议应用设置里配置，或用 WEAVER_MEETING_FIXED_FLOW_IDS 指定默认流程');
     }
     // 多个流程时先不拍板：由调用方探测"当前人员对每个流程有没有发起权限"，再决定是否让用户选。
     return { workflowId: candidates.length === 1 ? candidates[0] : '', candidates, source: 'settings' };
 }
+function pad2(value) {
+    return String(value).padStart(2, '0');
+}
+/** 明天的 yyyy-MM-dd：用户只说"开个会"没给日期时的兜底查找日。 */
+function tomorrowIso() {
+    const date = new Date(Date.now() + 24 * 60 * 60 * 1000);
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+/** Date → "yyyy-MM-dd HH:mm"。 */
+function formatMinute(date) {
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} `
+        + `${pad2(date.getHours())}:${pad2(date.getMinutes())}`;
+}
+/**
+ * 并行探测一组流程 id 的可发起性（`workflow.createForm` 能载入 = 当前账号有发起权限）。
+ * 抽出来是因为"固化 id 全不可发起 → 回退应用设置再探一轮"要复用同一段逻辑。
+ */
+async function probeWorkflowCandidates(env, ids) {
+    const probed = await Promise.all(ids.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),
+                },
+            };
+        }
+    }));
+    const probes = [];
+    const loadedForms = new Map();
+    for (const item of probed) {
+        if (item.probeForm)
+            loadedForms.set(item.id, item.probeForm);
+        probes.push(item.probe);
+    }
+    return { probes, loadedForms };
+}
 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 载入建会流程表单，把会议字段按中文名映射成表单值，返回预览与确认票据（不提交）',
+    summary: '流程建会（准备）：用固化流程候选逐个探测发起权限 —— 仅 1 个可发起就自动用它、多个都可发起则返回选项让用户选、'
+        + '都不可发起报「没有发起权限」；不传 begin_datetime 时自动推荐「人+会议室都空闲」的时段。只出预览与确认票据，不提交',
     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）' },
+        begin_datetime: {
+            ...SCHEMA_DATETIME_MINUTE,
+            description: '开始时间（yyyy-MM-dd HH:mm）。**可以不传**：不传会按参会人与会议室空闲情况推荐 3 个时段让你选；'
+                + '只传开始时间、不传结束时间时，按 durationMinutes（默认 60 分钟）自动算结束时间',
+        },
+        end_datetime: {
+            ...SCHEMA_DATETIME_MINUTE,
+            description: '结束时间（yyyy-MM-dd HH:mm）；不传则按 durationMinutes 从开始时间推算（默认 60 分钟）',
+        },
         mt_desc: { type: 'string', description: '会议内容/说明' },
         address: { type: 'string', description: '会议室（名称或 id，按流程表单字段要求）' },
         customize_address: { type: 'string', description: '自定义会议地点' },
@@ -257,6 +523,11 @@ const ebMeetingCreateFlowPrepare = {
         total_member: { type: 'number', description: '参会人数' },
         caller: { type: 'string', description: '召集人' },
         contacter: { type: 'string', description: '联系人' },
+        mt_type: {
+            type: 'string',
+            description: '会议类型：可传类型名称或 id（先用 `meeting.eb.type.list` 查有哪些）。'
+                + '**很多租户的流程表单把「会议类型」设为必填**，不传会被 `workflow.createRequest` 打回缺字段',
+        },
         other_remark: { type: 'string', description: '备注' },
         workflowId: {
             oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
@@ -266,93 +537,62 @@ const ebMeetingCreateFlowPrepare = {
         },
         autoRoom: { type: 'boolean', description: '默认 false：未指定会议室时返回候选让用户选；传 true 才自动采用推荐' },
         allowNoRoom: { type: 'boolean', description: '确实不需要会议室（线上会等）时传 true，避免被“请选择会议室”拦住' },
+        timeConfirmed: {
+            type: 'boolean',
+            description: '⛔ **时间的"用户已确认"标记**。只有以下两种情况才传 true：'
+                + '① 用户原话里明确给出了时间（如"明天 9 点到 10 点"）；'
+                + '② 用户在时段选项里点选后，把 `options[].value` **整体**原样回传（value 自带该标记）。'
+                + '不传 = 未确认：即使你传了 begin_datetime，CLI 也**不会**当成已定，而是返回时段选项让用户点选。'
+                + '⛔ 用户只说"明天/上午/下午"这类模糊说法时，**必须不传**，让 CLI 给候选',
+        },
+        roomConfirmed: {
+            type: 'boolean',
+            description: '⛔ **会议室的"用户已确认"标记**。只有以下两种情况才传 true：'
+                + '① 用户原话明确指定了某间会议室；② 用户在房间选项里点选后把 `options[].value` 整体原样回传。'
+                + '不传 = 未确认：即使传了 address，CLI 也会把"你指定的这间"和推荐候选一起列出来让用户点选。'
+                + '⛔ 不要自己从 room.list / room.recommend 里挑一间塞进 address —— 那是替用户拍板',
+        },
         extraFields: {
             type: 'object',
             description: '按**流程表单里的字段名**填额外字段，形如 {"参会客户": "xx公司", "联系方式": "138xxxx"}'
                 + '：用于租户在流程表单上自建、CLI 内置别名里没有的字段。键必须与该流程表单的字段名完全一致'
-                + '（prepare 的 warnings 会列出表单现有全部字段名）；匹配不到的会进 unmapped 提示，不会瞎填',
+                + '（prepare 的 warnings 会列出表单现有全部字段名）；匹配不到的会进 unmapped 提示，不会瞎填。'
+                + '⛔ **会议地点 / 参会人员 / 召集人 / 联系人 / 会议类型 不要塞这里** —— 它们有专用入参'
+                + '（address / hrm_members / caller / contacter / mt_type），CLI 会把值补成浏览按钮要的'
+                + ' `{id,name}` 对象；塞进 extraFields 会按纯文本提交，服务端会打回「请按名称选择」',
         },
-    }, { required: ['mt_name', 'begin_datetime', 'end_datetime'] }),
+        dateFrom: {
+            type: 'string',
+            description: '没给具体时间时按哪一天推荐时段（yyyy-MM-dd；不传默认明天）',
+        },
+        durationMinutes: {
+            type: 'number',
+            description: '会议时长（分钟，默认 60）：只给了开始时间时用来算结束时间；推荐时段时也按这个时长找',
+        },
+        workStartHour: { type: 'number', description: '推荐时段的最早小时（默认 9）' },
+        workEndHour: { type: 'number', description: '推荐时段的最晚小时（默认 18）' },
+        fieldValues: {
+            type: 'object',
+            additionalProperties: true,
+            description: '按**表单字段 datakey（fieldId）**直接给值，形如 {"1325677252711735881": "研讨会"}。'
+                + '优先级最高（同名字段以它为准）：适合字段名带提示语、或租户自建字段这类按中文名猜不到的情况。'
+                + 'datakey 从 prepare 返回的 preview.mapped（形如 "会议名称(1325677252711735881)"）里取；'
+                + '每个流程的 datakey 固定不变，可长期硬编码。',
+        },
+        flowChoice: {
+            type: 'string',
+            enum: ['auto', 'ask'],
+            description: '多个建会流程**都有发起权限**时怎么办：**默认（不传 / ask）= 返回选项让用户挑**；'
+                + 'auto = 自动取优先级最高的那个（省一轮，但选错流程会漏字段，慎用）。'
+                + '只有 1 个有权限时不受此参数影响，CLI 直接发起',
+        },
+    }, { required: ['mt_name'] }),
     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) {
-            // 有多个建会流程候选（应用设置配了多个，或入参传了多个 id）：**逐个探测当前人员能否发起**
-            // （createForm 能载入 = 有发起权限），不能默认拿第一个就提交 —— 用户可能对第一个没有发起权限，
-            // 也可能各流程表单字段完全不同（2026-10-28 / 2026-10-29 用户两次要求）。
-            // 并行探测：每个流程一次 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', `${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: `${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: [
-                        `${sourceLabel}了 ${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-30 顺序调整：**先确认四要素（名称 / 时间 / 参会人 / 地点），最后才定流程**。
+        // 流程探测与选择整体后移到房间闸门之后（见下方「流程闸门」）；这里先占位，
+        // 好让前面的时间/会议室选择分支仍能带出"当前用的是哪条流程"（此刻通常还是空的）。
+        let workflowId = '';
+        let flowPickNote = null;
         // 走流程也要有"选会议室 / 选时间"的体验（2026-10-28 用户要求）。
         // ⚠️ 性能：会议室推荐、参会人冲突、共同空闲时段三件事**互相独立**，必须并行发；
         // 串行会把 3 段网络耗时叠加成"建个会要等好几分钟"（用户 2026-10-28 反馈）。
@@ -361,11 +601,118 @@ const ebMeetingCreateFlowPrepare = {
         // 适用场景：人、时间、房间都已经确定，只想尽快把会建出来（可省掉 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 ?? '')
+        let endText = String(args.end_datetime ?? '').trim();
+        const rawMembers = String(args.hrm_members ?? '')
             .split(/[,;，；\s]+/)
             .map((item) => item.trim())
             .filter((item) => item !== '');
+        // ⛔ 参会人冲突检测（conflict.member）与共同空闲时段（schedule.free）**要的是员工 id**，
+        // 传姓名会被接口拒 —— 两路 Promise 都是 `.catch(() => null)`，于是"检测没跑"和"检测通过"
+        // 在返回里长得一模一样，用户以为查过了（2026-10-30 真机：agent 传"易鹏"，两路全部静默跳过）。
+        // 所以这里先把姓名换成 id：纯数字直接用，姓名走 hrm.employee.query 反查（查不到保持原名，不猜）。
+        const nameLike = rawMembers.filter((item) => !/^\d+$/.test(item));
+        const nameToId = nameLike.length > 0
+            ? await import('./schedule.js')
+                .then((m) => m.resolveMemberIdsByName(env, nameLike))
+                .catch(() => new Map())
+            : new Map();
+        const memberIds = rawMembers.map((item) => nameToId.get(item) ?? item);
+        // ③ 时间闸门：**传了具体时间 ≠ 用户已经确认**。
+        // 2026-10-30 真机事故：用户只说"明天上午"，agent 自己挑了个 9:00–10:00 传进来，
+        // CLI 当成"已定"直接进确认摘要，用户看到「时间：09:00–10:00」质问"谁决定的"。
+        // 所以只有 `timeConfirmed: true`（用户原话明确给了时间，或用户在选项里点选后把 value 原样回传）
+        // 才认这个时间；否则一律返回时段选项让用户点 —— 宁可多问一轮，也不替用户拍板。
+        const timeConfirmed = args.timeConfirmed === true;
+        // ⛔ 2026-10-30 真机：agent 在用户只说"明天上午"时就自己塞了 workflowId，
+        // 于是它脑内"流程已定"，回复里先讲流程再问时间（用户投诉顺序反了）。
+        // 时间/地点闸门阶段流程根本没定 —— 这里只做提示，不阻断（用户可能确实点名了流程，
+        // 那种情况下这个提示也算说明"流程还没到提交"）。
+        const callerWorkflowId = String(args.workflowId ?? '').trim();
+        const earlyWorkflowNote = callerWorkflowId === ''
+            ? ''
+            : `⛔ 你传了 workflowId=${callerWorkflowId}，但**流程还没到确认步骤**（顺序是 名称→时间→参会人→地点→流程）。`
+                + '本次只处理时间/地点；⛔ 不要在回复里说"按 X 流程发起"——四要素定完后 CLI 会返回流程选项让用户点。';
+        const beginHasTime = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}/.test(beginText);
+        const endHasTime = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}/.test(endText);
+        if (beginHasTime && !endHasTime) {
+            // 只给了开始时间：按 durationMinutes（默认 60）补齐结束时间，不必打断用户。
+            const duration = Number(args.durationMinutes) > 0 ? Math.round(Number(args.durationMinutes)) : 60;
+            const startMs = Date.parse(beginText.slice(0, 16).replace(' ', 'T'));
+            if (Number.isFinite(startMs))
+                endText = formatMinute(new Date(startMs + duration * 60000));
+        }
+        if (!beginHasTime || !timeConfirmed) {
+            const day = /^\d{4}-\d{2}-\d{2}/.test(beginText)
+                ? beginText.slice(0, 10)
+                : (String(args.dateFrom ?? '').trim().slice(0, 10) || tomorrowIso());
+            const duration = Number(args.durationMinutes) > 0 ? Math.round(Number(args.durationMinutes)) : 60;
+            const { getMeetingOperation } = await import('../registry.js');
+            const suggested = await getMeetingOperation('meeting.eb.meeting.create.suggest').handler({
+                dateFrom: day,
+                durationMinutes: duration,
+                hrm_members: memberIds.join(','),
+                maxSlots: 3,
+                topN: 3,
+                ...(Number(args.total_member) > 0 ? { memberCount: Number(args.total_member) } : {}),
+                ...(args.workStartHour !== undefined ? { workStartHour: Number(args.workStartHour) } : {}),
+                ...(args.workEndHour !== undefined ? { workEndHour: Number(args.workEndHour) } : {}),
+            }, env).catch((error) => ({ data: { slots: [] }, slotError: String(error?.message ?? error).slice(0, 160) }));
+            const slotOptions = (suggested?.data?.slots ?? []);
+            const slotWarnings = [
+                ...(suggested?.warnings ?? []),
+                ...(suggested?.slotError ? [`时段推荐未跑成功：${suggested.slotError}`] : []),
+                ...(memberIds.length === 0
+                    ? ['⚠️ 没有参会人员，无法核验"人是否空闲" —— 下面只是**会议室有空**的时段，请如实说明。']
+                    : []),
+            ];
+            return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                status: 'NEEDS_SELECTION',
+                selectionType: 'slot',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'T1' },
+                message: slotOptions.length > 0
+                    ? `${beginHasTime
+                        ? `你传入的时间 ${beginText}~${endText} **未经用户确认**（没带 timeConfirmed）`
+                        : '没有给出具体时间'}，已按参会人与会议室空闲情况推荐 ${slotOptions.length} 个时段`
+                        + `（${day}，时长 ${duration} 分钟）—— ⛔ 必须让用户在选项里点选，`
+                        + '**不要**把任何一个候选写成"已定"或放进确认摘要'
+                    : `${beginHasTime
+                        ? `你传入的时间 ${beginText}~${endText} 未经用户确认（没带 timeConfirmed）`
+                        : '没有给出具体时间'}，且 ${day} 没能找到「参会人空闲 + 会议室空闲」的时段，`
+                        + '请让用户换个日期或指定时间',
+                options: slotOptions.map((slot, index) => ({
+                    key: `T${index + 1}`,
+                    label: String(slot.label ?? ''),
+                    // ⛔ 时间不在 slot 顶层，而在 slot.value 里（suggest 的返回结构）—— 取错会让调用方
+                    // 拿不到 begin/end，只能再问用户一次时间（2026-10-30 冒烟实测踩到）。
+                    // `timeConfirmed: true` 在这里是**关键**：用户点选后 value 原样回传，下一轮才被认作"已确认"；
+                    // agent 自己编的时间不带这个标记，就永远停在选项这一步。
+                    value: {
+                        begin_datetime: String(slot.value?.begin ?? slot.begin ?? '').trim(),
+                        end_datetime: String(slot.value?.end ?? slot.end ?? '').trim(),
+                        address: slot.value?.address ?? null,
+                        timeConfirmed: true,
+                    },
+                    reason: String(slot.reason ?? ''),
+                    rooms: slot.rooms ?? [],
+                })),
+                day,
+                durationMinutes: duration,
+                memberIds,
+                // ⛔ 这里**不能**出现 workflowId：流程确认在四要素之后（2026-10-30 顺序调整）。
+                // 返回 workflowId 会让 agent 误以为"流程已定"，于是在回复里先讲流程、再问时间。
+                workflowPending: true,
+                hint: '选定后把 value **整体**原样带回重新调用（含 timeConfirmed: true）；'
+                    + 'address 已自动带上该时段可用的会议室，仍需让用户单独确认或用 roomConfirmed: true',
+            }, {
+                warnings: [
+                    `${beginHasTime
+                        ? `本次**没有提交**：你传入的时间 ${beginText}~${endText} 没有用户确认标记（timeConfirmed），已改为给候选。`
+                        : '本次**没有提交**：时间未确定（缺 begin_datetime）。'}已按 ${day} 推荐时段，请用选项让用户挑一个。`,
+                    ...slotWarnings,
+                    ...(earlyWorkflowNote ? [earlyWorkflowNote] : []),
+                ],
+            });
+        }
         let addressInput = args.address;
         // 记录"用户有没有自己指定会议室"：后面决定文案是"按你的指定"还是"自动选择"。
         const hadAddressInput = String(args.address ?? '').trim() !== '';
@@ -377,29 +724,52 @@ const ebMeetingCreateFlowPrepare = {
         const startedAt = Date.now();
         // 推荐照常跑：**即使调用方指定了会议室**也要跑 —— 一来说明"你指定的那间是否被占用"，
         // 二来冲突时能立刻给出替代候选（2026-10-29 用户明确要求：指定了也要判冲突、冲突了要推荐）。
+        // ⛔ 这几路增强检测失败**必须留下痕迹**：以前统一 `.catch(() => null)`，
+        // 结果"没查"和"查了没冲突"在返回里长得一模一样 —— 用户以为核验过了（2026-10-30 真机事故）。
+        const enrichFailures = [];
+        const noteFailure = (label) => (error) => {
+            enrichFailures.push(`${label}未完成：${String(error?.message ?? error).slice(0, 120)}`);
+            return null;
+        };
+        // ⛔ 会议人数要含召集人：`hrm_members` 通常只列"其他参会人"，召集人是自己。
+        // 以前直接用 `memberIds.length`，1 个参会人就按 1 人算 → 容量下限 2 人的房间把它判死，
+        // 出现「可用 1 间却被过滤成 0 候选」（2026-10-30 真机：易鹏 1 人 → 测试会议室1 1/2 被排除）。
+        const declaredTotal = Number(args.total_member) > 0 ? Number(args.total_member) : null;
+        const callerToken = String(args.caller ?? '').trim();
+        const callerInMembers = callerToken !== '' && (rawMembers.includes(callerToken) || memberIds.includes(callerToken));
+        const roomMemberCount = declaredTotal
+            ?? (memberIds.length > 0 ? memberIds.length + (callerInMembers ? 0 : 1) : undefined);
         const roomTask = (enrich && beginText && endText)
             ? recommendRooms(env, {
                 beginDatetime: beginText,
                 endDatetime: endText,
-                ...(memberIds.length > 0 ? { memberCount: memberIds.length } : {}),
+                ...(roomMemberCount ? { memberCount: roomMemberCount } : {}),
+                // 建会是"要下单"的场景：宁可多一次请求也必须拿最新台账（24h 缓存会让刚导入的会议室看不到）。
+                refreshRooms: true,
                 topN: 3,
-            }).catch(() => null)
+            }).catch(noteFailure('会议室推荐'))
             : Promise.resolve(null);
         // ⛔ 指定了会议室时，**单独查它在该时段是否已被占用**（query_roomusage_list）。
         // 以前 `!addressInput` 直接跳过整段 → "指定了一间被占用的房"照样往下走，用户到页面上才发现。
         const addressId = String(addressInput ?? '').trim();
         const addressIsRoomId = /^\d+$/.test(addressId);
+        // ④ 会议室闸门：与时间同理 —— 传了 address **不等于**用户确认过这间房。
+        // 只有 `roomConfirmed: true`（用户明确说了哪间，或在选项里点选后把 value 原样回传）才认；
+        // 否则返回房间选项让用户点。2026-10-30 同一事故：agent 把推荐房间写进确认摘要当定论。
+        const roomConfirmed = args.roomConfirmed === true;
         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)
+            })().catch(noteFailure('会议室**占用**检测'))
             : Promise.resolve(null);
+        // ⛔ 这三路检测失败**必须留下痕迹**：以前统一 `.catch(() => null)`，
+        // 结果"没查"和"查了没冲突"在返回里长得一模一样 —— 用户以为核验过了（2026-10-30 真机事故）。
         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)
+            })().catch(noteFailure('参会人**会议占用**检测'))
             : Promise.resolve(null);
         const availabilityTask = (enrich && beginText && endText && memberIds.length > 0)
             ? findCommonFreeSlots(env, {
@@ -410,23 +780,55 @@ const ebMeetingCreateFlowPrepare = {
                 maxSlots: 3,
                 maxDays: 1,
                 includeSchedule: true,
-            }).catch(() => null)
+            }).catch(noteFailure('参会人**日程空闲**检测'))
             : Promise.resolve(null);
         const [roomRec, memberConflict, free, roomConflict] = await Promise.all([
             roomTask, conflictTask, availabilityTask, roomConflictTask,
         ]);
         timings.parallelMs = Date.now() - startedAt;
+        // 参会人冲突 / 共同空闲时段**已经并行算完了**。即使接下来要先让用户选会议室，
+        // 也必须把这两项结论一起交出去 —— 否则用户选完房才知道时间撞了，等于白选一次
+        // （2026-10-30 真机：会议室查不到 → 卡在选房 → 冲突结论永远拿不到，用户以为"没判断"）。
+        const memberConflicts = (memberConflict?.data?.conflicts ?? []);
+        if (memberConflicts.length > 0)
+            decisions.memberConflicts = memberConflicts;
+        const freeSlots = free?.slots ?? [];
+        if (free) {
+            decisions.scheduleItems = free.scheduleItems;
+            decisions.availabilityCost = free.cost;
+            if (freeSlots.length > 0) {
+                decisions.suggestedSlots = freeSlots;
+                decisions.slotOptions = freeSlots.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 };
+            }
+        }
+        // 选房阶段也要能看到"时间到底冲不冲突"，否则等于没查。
+        const conflictBrief = {
+            memberConflicts,
+            suggestedSlots: freeSlots,
+            ...(enrichFailures.length > 0 ? { enrichFailures } : {}),
+        };
+        const failureWarnings = enrichFailures.map((failure) => `⚠️ ${failure} —— **这不代表没有冲突**，请如实告知用户该项未核验，不要声称"时间已确认空闲"`);
         // 会议室候选（指定/未指定都用这一份）：冲突时直接拿它当替代方案。
         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 },
+            // roomConfirmed: true = 用户点选该选项即代表"确认用这间"，原样回传后下一轮才被认。
+            value: { id: candidate.id, name: candidate.name, roomConfirmed: true },
             reason: candidate.reasons.join('；'),
         }));
         // ① 指定的会议室该时段已被占用 → 不替用户改，但必须拦下来并给替代候选。
         const roomConflictData = roomConflict?.data;
-        if (addressInput && roomConflictData?.hasConflict === true) {
+        // 只有"用户已确认这间房"时才按占用拦截；未确认的只是候选，交给下面的选房分支处理。
+        if (addressInput && roomConfirmed && roomConflictData?.hasConflict === true) {
             const busy = Array.isArray(roomConflictData.conflicts) ? roomConflictData.conflicts : [];
             decisions.roomConflict = {
                 address: addressId,
@@ -439,8 +841,10 @@ const ebMeetingCreateFlowPrepare = {
             return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
                 status: 'NEEDS_SELECTION',
                 selectionType: 'room_conflict',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'R1' },
                 message: `你指定的会议室在 ${beginText}~${endText} 已被占用（${busy.length} 条占用记录），`
                     + '本次**没有提交**。请改用下面空闲的会议室，或调整会议时间',
+                workflowPending: true,
                 options: roomOptions,
                 recommended: roomOptions[0]?.value ?? null,
                 conflicts: busy,
@@ -466,18 +870,53 @@ const ebMeetingCreateFlowPrepare = {
             // 会议室**不替用户决定**（用户明确要求：即使是常用会议室，也必须推荐出来让选择）。
             // 只有显式 `autoRoom: true` 才自动选中；否则返回 NEEDS_SELECTION，把候选交给调用方去问。
             const autoRoom = args.autoRoom === true;
-            if (!addressInput && !autoRoom && roomOptions.length > 0 && args.allowNoRoom !== true) {
+            // 传了房间但没用户确认标记 → 同样要给选项：把"你指定的那间"排到第一位，其余房间照常列在下面。
+            // 2026-10-30 事故：agent 自己挑了「测试会议室1」传进来，CLI 直接用，用户问"会议室没让我选"。
+            const needRoomPick = !addressInput || !roomConfirmed;
+            let pickOptions = roomOptions;
+            if (addressInput && !roomConfirmed) {
+                const hit = roomOptions.find((item) => String(item.value?.id) === addressId);
+                const specified = hit
+                    ? { ...hit, label: `${hit.label}（你指定的，待确认）`, value: { ...hit.value, roomConfirmed: true } }
+                    : {
+                        key: 'R0',
+                        label: `${addressInput}（你指定的，待确认）`,
+                        value: { ...(addressIsRoomId ? { id: addressId } : {}), name: addressInput, roomConfirmed: true },
+                        reason: '你传入的会议室，未提交、未确认',
+                    };
+                pickOptions = [specified, ...roomOptions.filter((item) => String(item.value?.id) !== addressId)]
+                    .map((item, index) => ({ ...item, key: `R${index + 1}` }));
+            }
+            if (needRoomPick && !autoRoom && pickOptions.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',
+                    ui: { component: 'choice', multiple: false, recommendedKey: 'R1' },
+                    message: addressInput
+                        ? `你传入的会议室「${addressInput}」**未经用户确认**（没带 roomConfirmed），已把它和其它候选一起列出来`
+                            + ' —— ⛔ 必须让用户在选项里点选，不要直接提交'
+                        : `未指定会议室，请从 ${pickOptions.length} 个候选里选择（已按人数/常用/时段占用排序）`,
+                    // 固化自动选的流程要带出来：调用方下一轮带 address 重调时不用再猜用的是哪条流程。
+                    workflowPending: true,
+                    options: pickOptions,
+                    recommended: pickOptions[0]?.value ?? null,
+                    hint: '选定后把 value **整体**原样带回（含 roomConfirmed: true）；'
+                        + '确实不需要会议室请传 allowNoRoom: true',
+                    ...conflictBrief,
                 }, {
                     warnings: [
-                        '未指定会议室：本次**没有**提交，也没有替用户挑房间。',
+                        addressInput
+                            ? `会议室「${addressInput}」未经用户确认：本次**没有**提交。`
+                            : '未指定会议室：本次**没有**提交，也没有替用户挑房间。',
                         '如需直接建会并沿用推荐，可传 autoRoom: true；不需要会议室则传 allowNoRoom: true。',
+                        ...(earlyWorkflowNote ? [earlyWorkflowNote] : []),
+                        ...(memberConflicts.length > 0
+                            ? [`⚠️ 注意：参会人在该时段已有 ${memberConflicts.length} 场会议冲突 —— 选房前先把这条告诉用户，别让他选完才发现。`]
+                            : []),
+                        ...(freeSlots.length > 0
+                            ? [`当天全部参会人都空闲的时段：${freeSlots.map((s) => `${s.begin.slice(11)}~${s.end.slice(11)}`).join('、')}`]
+                            : []),
+                        ...failureWarnings,
                     ],
                 });
             }
@@ -501,40 +940,199 @@ const ebMeetingCreateFlowPrepare = {
             return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
                 status: 'NEEDS_SELECTION',
                 selectionType: 'room_unavailable',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'C2' },
                 message: '未指定会议室，且按人数/时段没能推荐出可用的空闲会议室。'
                     + '请让用户从下面三条里选一条，**不要**直接提交一个没有地点的会议',
+                workflowPending: true,
                 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,
+                ...conflictBrief,
             }, {
                 warnings: [
                     `会议室推荐无结果：${String(decisions.roomUnavailable.reason)}。本次**没有提交**。`,
                     '确实不需要会议室（线上会）就带 allowNoRoom: true 重新调用；要指定房间就带 address。',
+                    ...(memberConflicts.length > 0
+                        ? [`⚠️ 另外：参会人在该时段已有 ${memberConflicts.length} 场会议冲突 —— 换时间可能比换房间更划算。`]
+                        : []),
+                    ...(freeSlots.length > 0
+                        ? [`当天全部参会人都空闲的时段：${freeSlots.map((s) => `${s.begin.slice(11)}~${s.end.slice(11)}`).join('、')}`]
+                        : []),
+                    ...failureWarnings,
                 ],
             });
         }
-        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: '该时段所有参会人都没有会议与日程占用（已同时核对会议回执与日程）',
-                }));
+        // 兜底：会议室推荐整段没跑出来（roomRec 为空）时，传了房间但**没用户确认**的也不能默默通过。
+        if (enrich && addressInput && !roomConfirmed && roomOptions.length === 0 && args.allowNoRoom !== true) {
+            const specified = {
+                key: 'R1',
+                label: `${addressInput}（你指定的，待确认）`,
+                value: { ...(addressIsRoomId ? { id: addressId } : {}), name: addressInput, roomConfirmed: true },
+                reason: '你传入的会议室，未提交、未确认',
+            };
+            return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                status: 'NEEDS_SELECTION',
+                selectionType: 'room',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'R1' },
+                message: '你传入的会议室未经用户确认，且本次没能推荐出其它候选 —— '
+                    + '请让用户确认这一间，或换一间 / 改时段',
+                workflowPending: true,
+                options: [specified],
+                recommended: specified.value,
+                hint: '用户确认用这间就把 value 原样带回（含 roomConfirmed: true）',
+            }, {
+                warnings: ['会议室未经用户确认，本次**没有**提交。', ...failureWarnings],
+            });
+        }
+        // ══════════════ 流程闸门（2026-10-30 顺序调整：放在四要素之后） ══════════════
+        // 用户要求：「先确认 时间/人/地点/名称 这四要素，再选流程发起」，不是反过来。
+        // 理由：流程只是承载体，用户先要确定"这会到底开不开、什么时候开、在哪开、谁参加"，
+        // 到这一步都定了，最后再让他挑"用哪条流程走审批"。所以时间/房间闸门都在上面，
+        // 到这里四要素已经齐了（时间带 timeConfirmed、地点带 roomConfirmed），只剩流程没定。
+        const resolved = await resolveWorkflowId(env, args);
+        // 地点还原成**人看得懂的名字**（address 入参可能是 id）：用户看确认摘要不能是一串数字。
+        const confirmedAddressId = String(addressInput ?? '').trim();
+        const confirmedAddressLabel = confirmedAddressId === ''
+            ? ''
+            : (String(roomOptions.find((item) => String(item.value?.id ?? '') === confirmedAddressId)
+                ?.value?.name ?? '') || confirmedAddressId);
+        const confirmedWhen = `${beginText}~${String(endText).slice(11) || endText}`;
+        let candidates = resolved.candidates;
+        workflowId = resolved.workflowId;
+        // 候选来源决定文案：固化配置（带环境名）/ 调用方传入 / 应用设置配置。
+        let sourceLabel = resolved.source === 'argument'
+            ? '调用方传入'
+            : (resolved.source === 'fixed'
+                ? `固化配置（${resolved.label ?? '默认'}）`
+                : '应用设置配置');
+        let probes = [];
+        let loadedForms = new Map();
+        // 固化自用场景：多个流程都能发起时自动取优先级最高的，不再打断用户去选（2026-10-30 要求）。
+        const autoPick = shouldAutoPickFlow(args);
+        if (!workflowId && candidates.length > 1) {
+            // 有多个建会流程候选：**逐个探测当前人员能否发起**（createForm 能载入 = 有发起权限）。
+            // 并行探测：每个流程一次 createForm（内含多次 OA 请求），串行会成倍放大等待。
+            let probed = await probeWorkflowCandidates(env, candidates);
+            probes = probed.probes;
+            loadedForms = probed.loadedForms;
+            let launchable = probes.filter((probe) => probe.launchable);
+            if (launchable.length === 0 && resolved.source === 'fixed') {
+                // 固化 id 在当前环境一个都发起不了（换租户/换环境时会出现）→ 回退应用设置再探一轮，
+                // 别因为固化就把"流程建会"这条路堵死。
+                const settings = await fetchEbAppSettings(env, 'meeting.eb.meeting.create.flow.prepare');
+                const fallbackIds = String(settings.mtNewWf ?? '')
+                    .split(/[,;，；\s]+/)
+                    .map((item) => item.trim())
+                    .filter((item) => item !== '');
+                if (fallbackIds.length > 0) {
+                    probed = await probeWorkflowCandidates(env, fallbackIds);
+                    probes = probed.probes;
+                    loadedForms = probed.loadedForms;
+                    candidates = fallbackIds;
+                    sourceLabel = '应用设置配置';
+                    launchable = probes.filter((probe) => probe.launchable);
+                }
             }
-            else if (free.blockingSummary) {
-                decisions.dayBlocked = { day, summary: free.blockingSummary };
+            if (launchable.length === 0) {
+                // 一个都发不起 → 就是"没有流程发起权限"（2026-10-30 用户要求明确提示，别让 agent 反复重试或改走直连）。
+                throw meetingValidationError('flow_not_launchable', `当前账号**没有发起建会流程的权限**：${sourceLabel}的 ${candidates.length} 个建会流程都发起不了`
+                    + `（无发起权限或流程已停用）——${probes.map((probe) => `${probe.workflowId}（${probe.reason ?? '不可发起'}）`).join('；')}。`
+                    + '请如实告知用户：需要找管理员开通该流程的发起权限，或请有权限的同事代为发起；'
+                    + '**不要**改用直连建会绕过流程管控。', { probes });
+            }
+            if (launchable.length > 1 && !autoPick) {
+                // 仍有多个可选 → 交给用户挑，不替用户决定（用户明确要求"以选择的方式"）
+                return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                    status: 'NEEDS_SELECTION',
+                    // ⚠️ 以前漏了这个字段（agent 拿到 undefined 无法判断是哪类选择，2026-10-30 真机发现）。
+                    selectionType: 'flow',
+                    // 明确告诉调用方"这是一道选择题，请用选项控件呈现"，不要降级成文本列表
+                    // （2026-10-30 用户反馈：agent 把会议室候选写成文本 + "需要你指定一间"，没给选项卡）。
+                    ui: { component: 'choice', multiple: false, recommendedKey: 'W1' },
+                    // 四要素已经确认到这一步了：摘要一起给出去，用户只需点一下流程，就能直接提交。
+                    confirmed: {
+                        mt_name: String(args.mt_name ?? ''),
+                        begin_datetime: beginText,
+                        end_datetime: endText,
+                        address: confirmedAddressId || null,
+                        addressName: confirmedAddressLabel || null,
+                        hrm_members: memberIds,
+                    },
+                    message: `会议要素已确认（${String(args.mt_name ?? '')} · ${confirmedWhen}`
+                        + `${confirmedAddressLabel ? ` · ${confirmedAddressLabel}` : ' · 无会议室'}）；`
+                        + `当前账号对 ${sourceLabel}的 ${candidates.length} 个建会流程**都有发起权限**，`
+                        + '请让用户最后选一下「用哪条流程发起」—— **不要默认取第一个**（各流程表单字段可能完全不同，'
+                        + '选错会漏字段；2026-10-29 真实事故：取第一个导致字段全填不进另一条流程，'
+                        + '用户以为"系统只支持一条流程"）。⚠️ 只有其中 1 个有权限时 CLI 会直接发起，不会走到这一步',
+                    options: launchable.map((probe, index) => ({
+                        key: `W${index + 1}`,
+                        label: probe.name ? `${probe.name}（${probe.workflowId}）` : probe.workflowId,
+                        // ⛔ 把已确认的四要素一起带回去：用户点选流程后**原样回传 value** 就能直接出确认摘要，
+                        // 不用再走一遍时间/房间闸门（否则"先定四要素再选流程"会多出一轮无效往返）。
+                        value: {
+                            workflowId: probe.workflowId,
+                            begin_datetime: beginText,
+                            end_datetime: endText,
+                            timeConfirmed: true,
+                            ...(confirmedAddressId
+                                ? { address: confirmedAddressId, roomConfirmed: true }
+                                : {}),
+                        },
+                        reason: '当前账号有发起权限',
+                        // 把该流程的字段名如实带出来：不同流程字段差异很大（有的有设备需求/涉密项目，有的没有），
+                        // 用户要靠这个才能选对（2026-10-29 用户反馈：选错方式后字段全填不进去）。
+                        fields: (loadedForms.get(probe.workflowId)?.fields ?? []).map((f) => f.name).filter(Boolean),
+                    })),
+                    probes,
+                }, {
+                    warnings: [
+                        `${sourceLabel}：共 ${candidates.length} 个建会流程，其中 ${launchable.length} 个当前账号可发起；`
+                            + '**必须把这几个流程做成选项让用户挑一个，禁止自己替用户选**；选定后带单个 workflowId 重新 prepare。',
+                        ...probes.filter((probe) => !probe.launchable)
+                            .map((probe) => `流程 ${probe.workflowId} 当前账号无法发起（${probe.reason ?? '无权限'}），已排除`),
+                    ],
+                });
+            }
+            workflowId = launchable[0].workflowId;
+            if (launchable.length === 1 && candidates.length > 1) {
+                // 只有一条有权限 → 直接发起，但要说明"为什么没让你选"（其余流程是无权限，不是被忽略）。
+                const only = launchable[0];
+                flowPickNote = `${sourceLabel}：共 ${candidates.length} 个建会流程，当前账号只有`
+                    + `「${only.name ?? only.workflowId}」（${only.workflowId}）有发起权限，已直接用它发起`;
+            }
+            if (launchable.length > 1) {
+                // 固化自用：多个可发起时按候选顺序自动取第一个 —— 但必须留痕说明"还有别的可用流程"，
+                // 不能默默替用户决定（2026-10-30：用户要的是"直接发起"，不是"什么都别告诉我"）。
+                const picked = launchable[0];
+                const others = launchable.slice(1)
+                    .map((probe) => (probe.name ? `${probe.name}（${probe.workflowId}）` : probe.workflowId));
+                flowPickNote = `${sourceLabel}：共 ${candidates.length} 个建会流程，当前账号可发起 ${launchable.length} 个，`
+                    + `已按优先级自动选用「${picked.name ?? picked.workflowId}」（${picked.workflowId}）；`
+                    + `其他可用流程：${others.join('、')} —— 要用它们请显式传 workflowId。`;
+            }
+        }
+        // 单一候选（固化只配了 1 条 / 应用设置只配了 1 条 / 调用方指定了 1 条）时没有走"探测"分支，
+        // 载入失败同样是"没权限或流程停用" —— 必须给同一句人话，而不是把表单错误原样抛出去
+        // （2026-10-30：用户要求"都没权限就明确提示没有发起权限"）。
+        let form = loadedForms.get(workflowId);
+        if (!form) {
+            try {
+                form = await loadCreateForm(env, workflowId);
+            }
+            catch (error) {
+                throw meetingValidationError('flow_not_launchable', `当前账号**没有发起建会流程的权限**（或流程已停用）：建会流程 ${workflowId} 的表单载入失败 —— `
+                    + `${String(error?.message ?? error).slice(0, 200)}。`
+                    + '请如实告知用户：需要找管理员开通该流程的发起权限，或请有权限的同事代为发起；'
+                    + '**不要**改用直连建会绕过流程管控。', { workflowId });
             }
         }
+        if (!form.continuation) {
+            throw meetingValidationError('flow_context_missing', '建会流程表单没有返回 continuation，无法继续提交');
+        }
+        // 参会人冲突 / 空闲时段已在选房之前处理完（见上方 conflictBrief）。
         decisions.timings = timings;
         const shaped = await shapeBrowserValues(env, {
             mt_name: args.mt_name,
@@ -553,10 +1151,39 @@ const ebMeetingCreateFlowPrepare = {
                 ? args.extraFields
                 : {}),
         });
-        const { main, mapped, unmapped } = mapFields(form.fields, shaped.values);
+        // datakey 固化：上次解析出的「语义键 → fieldId」直接复用（表单字段改名也不影响），
+        // 本次解析结果再写回，形成"猜一次、之后一直用 datakey"的效果。
+        const preferredFields = await readFlowFieldMap(env, workflowId);
+        const { main, mapped, unmapped, resolved: resolvedFields } = mapFields(form.fields, shaped.values, preferredFields);
+        await writeFlowFieldMap(env, workflowId, form.workflowName, resolvedFields);
         const warnings = [];
+        // 固化自动选流程要留痕：调用方/用户能看到"用的是哪条、还有哪些可选"。
+        if (flowPickNote)
+            warnings.push(flowPickNote);
         for (const note of shaped.notes)
             warnings.push(note);
+        // datakey 直填（2026-10-30 用户建议）：按表单字段的 **datakey** 直接给值，跳过中文名匹配。
+        // 用在「字段名带提示语、别名表猜不到」或「租户自建字段」场景，比按中文名匹配稳。
+        if (args.fieldValues && typeof args.fieldValues === 'object' && !Array.isArray(args.fieldValues)) {
+            const knownIds = new Set(form.fields.map((field) => field.id));
+            for (const [fieldId, raw] of Object.entries(args.fieldValues)) {
+                if (raw === undefined || raw === null || raw === '')
+                    continue;
+                if (!knownIds.has(fieldId)) {
+                    warnings.push(`fieldValues 里的 datakey「${fieldId}」不在该流程表单里，已忽略（先用 prepare 不带 fieldValues 跑一次，看 unmapped/表单字段清单）`);
+                    continue;
+                }
+                main[fieldId] = raw;
+                mapped[`datakey:${fieldId}`] = fieldId;
+            }
+        }
+        // 增强检测没跑成功必须如实报出：否则调用方会把"未核验"当成"已核验且无冲突"。
+        if (enrichFailures.length > 0) {
+            decisions.enrichFailures = enrichFailures;
+            for (const failure of enrichFailures) {
+                warnings.push(`⚠️ ${failure} —— **这不代表没有冲突**，请如实告知用户该项未核验，不要声称"时间已确认空闲"`);
+            }
+        }
         const picked = decisions.autoRoom?.picked;
         // ⚠️ 只在"用户没指定会议室、由 CLI 自动选"时才说这句。
         // 以前无条件输出"未指定会议室 → 已自动选择"，用户明明传了 address 也被这么讲（2026-10-29 真机踩到）；
@@ -567,19 +1194,32 @@ const ebMeetingCreateFlowPrepare = {
                 + `另有候选 ${(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('；')}`
+        const memberConflictCount = decisions.memberConflicts?.length ?? 0;
+        if (memberConflictCount > 0 && slotOptions.length > 0) {
+            // ⚠️ 以前只要 slotOptions 非空就断言"参会人时间有冲突" —— 而 slotOptions 只是"当天全部空闲时段"，
+            // 当前时段本身空闲时也会命中，于是出现"memberConflicts=0 却提示有冲突"的自相矛盾（2026-10-30 真机）。
+            warnings.push(`参会人时间有冲突（${memberConflictCount} 条占用）；当天所有人都空的时段：`
+                + slotOptions.map((item) => `[${item.key}] ${item.label}`).join('；')
                 + '——请用选项方式让用户挑（选定后重新 prepare 并改时间）。');
         }
+        else if (memberConflictCount === 0 && slotOptions.length > 0) {
+            warnings.push('该时段参会人没有会议/日程占用（已核对会议回执与日程）。'
+                + `当天其他共同空闲时段：${slotOptions.map((item) => `[${item.key}] ${item.label}`).join('；')}`);
+        }
         else if (decisions.dayBlocked?.summary) {
             warnings.push(String(decisions.dayBlocked.summary));
         }
-        if (unmapped.length > 0) {
-            warnings.push(`以下字段没有在建会流程表单里找到同名字段，未自动填写：${unmapped.join('、')}`
+        // mt_name 不算"漏填"：表单没有「会议名称」字段时它已经用作流程标题（下面单独说明），
+        // 混在 unmapped 里会让 agent 以为还需要额外补字段。
+        const unmappedReal = unmapped.filter((name) => name !== 'mt_name');
+        if (unmappedReal.length > 0) {
+            warnings.push(`以下字段没有在建会流程表单里找到同名字段，未自动填写：${unmappedReal.join('、')}`
                 + `（表单现有字段：${form.fields.map((field) => field.name).join('、')}）`);
         }
         if (!main[form.fields.find((field) => field.name === '会议名称')?.id ?? ''] && !mapped.mt_name) {
-            warnings.push('建会流程表单里没找到「会议名称」字段，请人工确认流程是否配错');
+            // 不是配错：EB 的两条建会流程里，「会议申请流程」本身就没有「会议名称」字段，用流程标题代替。
+            warnings.push('该建会流程的表单没有「会议名称」字段（部分流程用流程标题代替会议名称，属正常配置，不是流程配错）。'
+                + '如需会议名称独立成字段，请改选带该字段的流程（如「会议申请流程（NEW）」）。');
         }
         const session = await env.host.getSession();
         const continuation = await env.continuation.issue({
@@ -593,6 +1233,8 @@ const ebMeetingCreateFlowPrepare = {
                 mtName: String(args.mt_name),
                 data: { main },
                 surfaceContinuation: form.continuation,
+                // 供 apply 在「会议还没生成」时按申请单信息预生成邀请函（预置函）
+                invitationFields: shaped.readable,
             },
             fingerprint: JSON.stringify({ workflowId, main }),
         }, 10 * 60 * 1000);
@@ -602,6 +1244,9 @@ const ebMeetingCreateFlowPrepare = {
                 workflowId,
                 workflowCandidates: candidates,
                 ...(probes.length > 0 ? { workflowProbes: probes } : {}),
+                ...(flowPickNote
+                    ? { workflowAutoPicked: { workflowId, source: resolved.source, note: flowPickNote } }
+                    : {}),
                 requestName: String(args.mt_name),
                 fieldMapping: mapped,
                 formData: { main },
@@ -613,6 +1258,49 @@ const ebMeetingCreateFlowPrepare = {
         }, warnings.length > 0 ? { warnings } : {});
     },
 };
+/**
+ * 按申请单已知信息预生成邀请函（**预置函**）。
+ *
+ * 会议还没生成时也必须给一份：流程还在审批、或小e 环境根本不回写服务端（BROWSER_FILL）时，
+ * 用户要的是"提交完立刻能拿到文件"，而不是等审批通过再回来补。取不到的字段由模板渲染成【待补充】。
+ */
+export async function renderPreInvitation(payload, env) {
+    const fields = payload?.invitationFields ?? {};
+    const started = Date.now();
+    try {
+        const { getMeetingOperation } = await import('../registry.js');
+        const render = getMeetingOperation('meeting.invitation.render');
+        const rendered = await render.handler({
+            mt_name: String(fields.mt_name ?? payload?.mtName ?? '').trim(),
+            begin_datetime: String(fields.begin_datetime ?? '').trim(),
+            end_datetime: String(fields.end_datetime ?? '').trim(),
+            address: String(fields.address ?? fields.customize_address ?? '').trim(),
+            hrm_members: String(fields.hrm_members ?? '').trim(),
+            mt_desc: String(fields.mt_desc ?? '').trim(),
+            org_members: String(fields.org_members ?? '').trim(),
+            caller: String(fields.caller ?? '').trim(),
+            contacter: String(fields.contacter ?? '').trim(),
+            total_member: String(fields.total_member ?? '').trim(),
+        }, env);
+        // 用 pending 标记「这份是按申请单预生成的，不是会议最终数据」：
+        // 调用方据此提示用户"会议生成后可用 mtId 重新生成一版拿完整字段"。
+        return {
+            invitation: { pending: true, preRendered: true, ...(rendered?.data ?? {}) },
+            ms: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            invitation: {
+                pending: true,
+                preRendered: false,
+                ok: false,
+                error: String(error?.message ?? error).slice(0, 200),
+            },
+            ms: Date.now() - started,
+        };
+    }
+}
 const ebMeetingCreateFlowApply = {
     name: 'meeting.eb.meeting.create.flow.apply',
     resource: 'eb',
@@ -676,6 +1364,35 @@ const ebMeetingCreateFlowApply = {
             });
         }
         if (!requestId) {
+            const submitStatus = String(submittedData.status ?? submitted?.status ?? '');
+            if (submitStatus === 'BROWSER_FILL') {
+                // 小e 环境：工作流**不向服务端写入**，改由宿主的浏览器页面完成填单（2026-10-15 裁定）。
+                // 所以这里永远拿不到 requestId / 会议 id —— 这不是失败，但也**不是"流程已提交"**，
+                // 不能报错把整轮卡死（用户要的表单就在 finalMarkdown 里）。
+                // ⛔ 邀请函必须照给：它是预置函，按申请单已知信息生成，不依赖会议是否已生成。
+                const pre = await renderPreInvitation(payload, env);
+                return meetingSuccess('meeting.eb.meeting.create.flow.apply', {
+                    status: 'BROWSER_FILL',
+                    workflowId: payload.workflowId,
+                    requestName: payload.requestName,
+                    requestId: null,
+                    meetingId: null,
+                    contextId: submittedData.contextId ?? null,
+                    // 宿主要靠这段 <browsertool> 才能把表单拉到浏览器里填，必须原样透出
+                    finalMarkdown: submittedData.finalMarkdown ?? null,
+                    message: String(submittedData.message ?? ''),
+                    invitation: pre.invitation,
+                    timings: { submitMs: Date.now() - submitStartedAt, invitationMs: pre.ms },
+                }, {
+                    warnings: [
+                        '当前是小e 环境：本次**没有向服务端写入**，建会流程改由浏览器页面完成填单（见 finalMarkdown）。'
+                            + '因此还没有 requestId / 会议 id，也**不能说"流程已提交"**。',
+                        `邀请函已按申请单信息**预生成**（预置函，${String(pre.invitation.filePath ?? '见 filePath')}）：`
+                            + '请下载后人工核对、自行发送；流程审批通过、会议生成后可用 mtId 再跑一次 meeting.invitation.render 拿完整字段版本。',
+                        '⛔ 不要因为"没有 requestId / 没有会议 id"重复 apply —— 填单要在那个浏览器页面里点提交。',
+                    ],
+                });
+            }
             // 没拿到 requestId 时**不能**说"流程已提交"：常见原因是必填项缺失（工作流只在 saveFormData 前校验），
             // 也可能只是存了草稿。把缺失项原样交回去，让调用方补字段，而不是含糊地说"已提交"。
             const missing = submittedData.missingFields ?? submittedData.requiredMissing ?? submittedData.missing ?? [];
@@ -741,9 +1458,16 @@ const ebMeetingCreateFlowApply = {
             }
         }
         else {
+            // ⛔ 不等于"没有邀请函"。邀请函本质是**预置函**（项目人员下载后自己改、自己发，
+            // 2026-10-30 用户明确要求），所以会议还在审批、尚未生成时，也要用申请单已知信息
+            // 先出一份，取不到的字段渲染成【待补充】。这样调用方/用户提交完立刻就能拿到文件。
+            const pre = await renderPreInvitation(payload, env);
+            invitation = pre.invitation;
+            timings.invitationMs = pre.ms;
             warnings.push(`流程已提交（requestId=${requestId || '未返回'}），但 ${waitSeconds}s 内没在会议表里查到「${payload.mtName}」——`
-                + '多数情况是还在审批中。审批通过后（或后台建会完成后）再跑一次 meeting.invitation.render 出邀请函；'
-                + '本 operation 不重复提交流程。');
+                + '多数情况是还在审批中。已按申请单信息**预生成**邀请函（属预置函，请人工核对后自行发送）；'
+                + '审批通过、会议生成后可用 mtId 再跑一次 meeting.invitation.render 拿到完整字段版本。'
+                + '⛔ 本 operation 不重复提交流程 —— 不要因为"没有会议 id"就重复 apply。');
         }
         return meetingSuccess('meeting.eb.meeting.create.flow.apply', {
             status: 'COMPLETE',
@@ -778,8 +1502,15 @@ const ebMeetingCreateFlowQuick = {
     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）' },
+        begin_datetime: {
+            ...SCHEMA_DATETIME_MINUTE,
+            description: '开始时间（yyyy-MM-dd HH:mm）。**可以不传**：不传会按参会人与会议室空闲情况推荐 3 个时段让你选；'
+                + '只传开始时间、不传结束时间时，按 durationMinutes（默认 60 分钟）自动算结束时间',
+        },
+        end_datetime: {
+            ...SCHEMA_DATETIME_MINUTE,
+            description: '结束时间（yyyy-MM-dd HH:mm）；不传则按 durationMinutes 从开始时间推算（默认 60 分钟）',
+        },
         mt_desc: { type: 'string', description: '会议内容/说明' },
         address: { type: 'string', description: '会议室（id 或名称；不传则返回候选让用户选，不会自动决定）' },
         customize_address: { type: 'string', description: '自定义会议地点' },
@@ -787,6 +1518,11 @@ const ebMeetingCreateFlowQuick = {
         total_member: { type: 'number', description: '参会人数' },
         caller: { type: 'string', description: '召集人' },
         contacter: { type: 'string', description: '联系人' },
+        mt_type: {
+            type: 'string',
+            description: '会议类型：可传类型名称或 id（先用 `meeting.eb.type.list` 查有哪些）。'
+                + '**很多租户的流程表单把「会议类型」设为必填**，不传会被 `workflow.createRequest` 打回缺字段',
+        },
         other_remark: { type: 'string', description: '备注' },
         workflowId: {
             oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
@@ -794,6 +1530,16 @@ const ebMeetingCreateFlowQuick = {
         },
         autoRoom: { type: 'boolean', description: '默认 false：不指定会议室时返回候选让用户选；传 true 才自动采用推荐会议室' },
         allowNoRoom: { type: 'boolean', description: '确实不需要会议室（线上会等）时传 true' },
+        timeConfirmed: {
+            type: 'boolean',
+            description: '时间的"用户已确认"标记：用户原话明确给了时间、或在时段选项里点选后原样回传 value（自带标记）时才传 true；'
+                + '不传 = 未确认，CLI 会返回时段选项让用户点选',
+        },
+        roomConfirmed: {
+            type: 'boolean',
+            description: '会议室的"用户已确认"标记：用户原话明确指定、或在房间选项里点选后原样回传 value（自带标记）时才传 true；'
+                + '不传 = 未确认，CLI 会把指定房间和候选一起列出来让用户点选',
+        },
         confirm: { type: 'boolean', description: '必须显式 true 才会真正提交' },
         waitSeconds: { type: 'number', description: '提交后等待会议生成的秒数（默认 20；算法是立即查一次 + 5s 再查一次，仍未生成就返回 pending）' },
         enrich: { type: 'boolean', description: '是否顺带做会议室推荐/冲突检测/空闲时段（默认 true；人、时间、房间都已确定时传 false 可显著加快）' },
@@ -801,7 +1547,29 @@ const ebMeetingCreateFlowQuick = {
             type: 'object',
             description: '按流程表单字段名填额外字段（租户自建字段用这个口子带进去），形如 {"参会客户": "xx公司"}',
         },
-    }, { required: ['mt_name', 'begin_datetime', 'end_datetime', 'confirm'] }),
+        dateFrom: {
+            type: 'string',
+            description: '没给具体时间时按哪一天推荐时段（yyyy-MM-dd；不传默认明天）',
+        },
+        durationMinutes: {
+            type: 'number',
+            description: '会议时长（分钟，默认 60）：只给了开始时间时用来算结束时间；推荐时段时也按这个时长找',
+        },
+        workStartHour: { type: 'number', description: '推荐时段的最早小时（默认 9）' },
+        workEndHour: { type: 'number', description: '推荐时段的最晚小时（默认 18）' },
+        fieldValues: {
+            type: 'object',
+            additionalProperties: true,
+            description: '按**表单字段 datakey（fieldId）**直接给值，形如 {"1325677252711735881": "研讨会"}；'
+                + '优先级最高，适合字段名带提示语或租户自建字段。datakey 见 prepare 的 preview.mapped',
+        },
+        flowChoice: {
+            type: 'string',
+            enum: ['auto', 'ask'],
+            description: '多个建会流程**都有发起权限**时：默认（不传 / ask）= 返回选项让用户挑；'
+                + 'auto = 自动取优先级最高的。只有 1 个有权限时直接发起',
+        },
+    }, { required: ['mt_name', 'confirm'] }),
     handler: async (args, env) => {
         if (args.confirm !== true) {
             throw meetingValidationError('confirmation_required', '一步建会会直接提交流程，必须显式传 confirm=true；如只想看方案，请用 meeting.eb.meeting.create.flow.prepare');
@@ -833,6 +1601,10 @@ const ebMeetingCreateFlowQuick = {
             requestId: applied?.data?.requestId,
             meetingId: applied?.data?.meetingId ?? null,
             invitation: applied?.data?.invitation ?? null,
+            // 小e 环境（BROWSER_FILL）不写服务端，表单靠这段 <browsertool> 在浏览器里填 —— 必须一起透出，
+            // 否则宿主拿不到表单，用户看到的就是"提交了但没反应"。
+            ...(applied?.data?.contextId ? { contextId: (applied?.data).contextId } : {}),
+            ...(applied?.data?.finalMarkdown ? { finalMarkdown: (applied?.data).finalMarkdown } : {}),
             decisions: prepared?.data?.preview?.decisions ?? null,
             timings: {
                 ...(prepared?.data?.preview?.decisions?.timings ?? {}),
@@ -845,7 +1617,148 @@ const ebMeetingCreateFlowQuick = {
         }, warnings.length > 0 ? { warnings } : {});
     },
 };
+/**
+ * 建会建议（只读）：给出「所有人都空闲 **且** 该时段有可用会议室」的时间候选。
+ *
+ * 为什么需要（2026-10-30 用户要求）：用户只说"明天"没说几点时，以前的处理只能是弹一个空输入框
+ * 让他自己填——等于把"找时间"这件最费脑子的事丢回给用户。而这信息 CLI 本来就能算：
+ *   `findCommonFreeSlots`（人员维度：会议回执 + 日程）→ `recommendRooms`（该时段空闲的会议室，含容量筛选）
+ * 组合起来就能直接给"明天 10:00–11:00，测试会议室1 空着"这种答案，不需要人填。
+ *
+ * ⛔ 用户明确要求两条都必须满足：**人员都空闲** + **会议室也空闲**。
+ * 所以这里会把"该时段没有任何可用会议室"的候选直接剔除，不给"时间有了但没房间"的假选项。
+ */
+const ebMeetingCreateSuggest = {
+    name: 'meeting.eb.meeting.create.suggest',
+    resource: 'eb',
+    method: 'meeting.eb.meeting.create.suggest',
+    action: 'meeting.eb.meeting.create.suggest',
+    summary: '建会建议：给定日期范围与参会人，推荐「所有人都空闲 + 该时段有可用会议室」的时间候选（只读，不建会）',
+    capability: 'eb.meeting',
+    risk: 'read',
+    inputSchema: schemaOf({
+        dateFrom: { type: 'string', description: '起始日期（必填，yyyy-MM-dd）' },
+        dateTo: { type: 'string', description: '结束日期（可选，默认同 dateFrom；最多跨 14 天）' },
+        durationMinutes: { type: 'number', description: '会议时长（分钟，默认 60）' },
+        hrm_members: { type: 'string', description: '参会人员（必填，员工 id 或姓名，逗号分隔；姓名会自动反查 id）' },
+        memberCount: { type: 'number', description: '参会人数（可选，用于会议室容量筛选；不传则按 hrm_members 个数）' },
+        workStartHour: { type: 'number', description: '只在几点以后找（默认 9）' },
+        workEndHour: { type: 'number', description: '只在几点以前找（默认 18）' },
+        maxSlots: { type: 'number', description: '最多给几个时间候选（默认 3，最大 8）' },
+        topN: { type: 'number', description: '每个时间候选最多带几间会议室（默认 3）' },
+        includeSchedule: { type: 'boolean', description: '是否把日程（ESB）也算进占用（默认 true）' },
+    }, { required: ['dateFrom', 'hrm_members'] }),
+    handler: async (args, env) => {
+        const dateFrom = String(args.dateFrom ?? '').trim().slice(0, 10);
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(dateFrom)) {
+            throw meetingValidationError('datetime_invalid', `dateFrom 必须是 yyyy-MM-dd，收到「${String(args.dateFrom ?? '')}」`);
+        }
+        const dateTo = String(args.dateTo ?? '').trim().slice(0, 10) || dateFrom;
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(dateTo)) {
+            throw meetingValidationError('datetime_invalid', `dateTo 必须是 yyyy-MM-dd，收到「${String(args.dateTo ?? '')}」`);
+        }
+        const durationMinutes = Number(args.durationMinutes) > 0 ? Number(args.durationMinutes) : 60;
+        const maxSlots = Math.max(1, Math.min(8, Number(args.maxSlots) || 3));
+        const topN = Math.max(1, Math.min(5, Number(args.topN) || 3));
+        // 参会人：纯数字当 id，姓名走 hrm.employee.query 反查（与 prepare 同一套口径）。
+        const rawMembers = String(args.hrm_members ?? '')
+            .split(/[,;，；\s]+/)
+            .map((item) => item.trim())
+            .filter((item) => item !== '');
+        const nameLike = rawMembers.filter((item) => !/^\d+$/.test(item));
+        const nameToId = nameLike.length > 0
+            ? await import('./schedule.js')
+                .then((m) => m.resolveMemberIdsByName(env, nameLike))
+                .catch(() => new Map())
+            : new Map();
+        const memberIds = rawMembers.map((item) => nameToId.get(item) ?? item);
+        const unresolved = rawMembers.filter((item) => nameToId.get(item) === undefined && !/^\d+$/.test(item));
+        // 会议人数要含召集人（自己）：`hrm_members` 通常只列"其他参会人"。
+        // 用当前登录 userId 判断自己是否已在列表里，避免重复 +1（2026-10-30：只传易鹏时按 1 人算，
+        // 容量下限 2 人的房间被误判"未达建议下限"）。
+        const selfId = await env.host.getSession().then((s) => String(s?.userId ?? '')).catch(() => '');
+        const selfIncluded = selfId !== '' && memberIds.includes(selfId);
+        const memberCount = Number(args.memberCount) > 0
+            ? Number(args.memberCount)
+            : (memberIds.length > 0 ? memberIds.length + (selfIncluded ? 0 : 1) : undefined);
+        const warnings = [];
+        if (unresolved.length > 0) {
+            warnings.push(`⚠️ 这些参会人没查到员工 id：${unresolved.join('、')} —— 已跳过，其空闲情况**未核验**`);
+        }
+        const free = await findCommonFreeSlots(env, {
+            rangeStart: `${dateFrom} 00:00`,
+            rangeEnd: `${dateTo} 23:59`,
+            durationMinutes,
+            members: memberIds,
+            maxSlots,
+            maxDays: 14,
+            includeSchedule: args.includeSchedule !== false,
+            ...(args.workStartHour !== undefined ? { workStartHour: Number(args.workStartHour) } : {}),
+            ...(args.workEndHour !== undefined ? { workEndHour: Number(args.workEndHour) } : {}),
+        });
+        // 每个"人空闲"的时段，再并行查该时段的可用会议室（用户要求：会议室也必须空闲）。
+        // 先强制刷新一次台账预热：否则 N 个时段会各自判断 24h 缓存、可能读到旧清单，
+        // 也可能同时发起 N 次全量拉取（2026-10-30：用户刚导入 100+ 间，推荐仍只看到 1 间）。
+        await loadRooms(env, { refresh: true }).catch(() => null);
+        const withRooms = await Promise.all((free.slots ?? []).map(async (slot) => {
+            try {
+                const rec = await recommendRooms(env, {
+                    beginDatetime: slot.begin,
+                    endDatetime: slot.end,
+                    ...(memberCount ? { memberCount } : {}),
+                    topN,
+                });
+                return {
+                    begin: slot.begin,
+                    end: slot.end,
+                    rooms: rec.candidates.map((candidate) => ({
+                        id: candidate.id,
+                        name: candidate.name,
+                        capacityMax: candidate.capacity.max,
+                        reasons: candidate.reasons,
+                    })),
+                };
+            }
+            catch {
+                return { begin: slot.begin, end: slot.end, rooms: [] };
+            }
+        }));
+        // 没有可用会议室的时段直接剔除 —— 不给"时间有了但没房间"的假选项。
+        const usable = withRooms.filter((slot) => slot.rooms.length > 0);
+        if (usable.length === 0) {
+            const why = (free.slots ?? []).length === 0
+                ? '该范围内所有参会人没有共同的空闲时段'
+                : `${(free.slots ?? []).length} 个「人空闲」的时段里，没有一个还能订到会议室`;
+            warnings.push(`没找到同时满足「人员空闲 + 会议室空闲」的时间候选：${why}。`
+                + '请如实告知用户，并建议换个日期范围、缩短时长，或改为线上会议（allowNoRoom: true）。');
+            if (free.blockingSummary)
+                warnings.push(`当天占用概况：${free.blockingSummary}`);
+        }
+        return meetingSuccess('meeting.eb.meeting.create.suggest', {
+            dateFrom,
+            dateTo,
+            durationMinutes,
+            // 同样是"让用户点一下"：时段候选用选项控件呈现，别写成文本列表
+            ui: { component: 'choice', multiple: false, recommendedKey: 'T1' },
+            slots: usable.map((slot, index) => ({
+                key: `T${index + 1}`,
+                label: `${slot.begin.slice(5, 10)} ${slot.begin.slice(11)}~${slot.end.slice(11)}`,
+                value: { begin: slot.begin, end: slot.end, address: slot.rooms[0]?.id ?? null },
+                reason: `${memberCount ? `${memberCount} 人全部空闲（会议回执 + 日程已核）；` : ''}`
+                    + `${slot.rooms.length} 间会议室可用：${slot.rooms.map((room) => room.name).join('、')}`,
+                rooms: slot.rooms,
+            })),
+            // 把"人空闲但没房间"的时段也带出来，方便调用方解释为什么被剔除
+            skippedSlots: withRooms.filter((slot) => slot.rooms.length === 0),
+            memberIds,
+            scheduleItems: free.scheduleItems,
+            idle: free.idle,
+            cost: free.cost,
+        }, warnings.length > 0 ? { warnings } : {});
+    },
+};
 export const meetingEbCreateFlowOperations = [
+    ebMeetingCreateSuggest,
     ebMeetingCreateFlowPrepare,
     ebMeetingCreateFlowApply,
     ebMeetingCreateFlowQuick,