weaver-work-cli 0.1.33 → 0.1.38

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

@@ -1,7 +1,12 @@
+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 { EB_BASE, ebBusinessSuccess, writeBody } from './factory.js';
+import { loadRooms, recommendRooms } from './room-recommend.js';
 /**
  * 通过**流程**新建 EB 会议（`meeting.eb.meeting.create.flow`）。
  *
@@ -30,11 +35,16 @@ const FIELD_ALIASES = {
     customize_address: ['自定义会议地点', '自定义地点'],
     hrm_members: ['参会人员', '参会人'],
     total_member: ['参会人数', '人数'],
+    /** 参会客户（CustomerComponent 客户浏览按钮）：值是客户 id 列表，不是客户名称文本。 */
+    crm_members: ['参会客户', '客户'],
+    crm_member_count: ['应到客户数', '客户数'],
     caller: ['召集人', '发起人'],
     contacter: ['联系人'],
     mt_type: ['会议类型'],
     other_remark: ['备注', '其他说明'],
 };
+/** 「召集人 / 联系人」两个人员字段的展示名（自动补齐时用来提示用户）。 */
+const PERSON_FIELD_LABELS = { caller: '召集人', contacter: '联系人' };
 function workflowEnv(env) {
     return env;
 }
@@ -88,37 +98,171 @@ async function resolveEmployeeNames(env, ids) {
     }
     return map;
 }
-/** 会议室 id → {id,name}（优先会议室缓存，缓存没有就查一次详情）。 */
-async function resolveRoomValue(env, input) {
+/**
+ * 把「员工 id 或姓名」解析成 `{ id, name }`。
+ *
+ * ⛔ 2026-10-31 修（用户实测反馈「参会人员没代入表单」）：以前只拿这些值当 id 去反查姓名，
+ * 传姓名时得到的是 `{ id: "王丹丹", name: "王丹丹" }` —— 浏览按钮按 **id** 落值，
+ * 服务端解析不出员工，表单里就渲染成空。现在纯数字当 id、其余当姓名去 `hrm.employee.query`
+ * 换真实员工 id；同名有歧义（命中多条且没有全等）时不猜，留给调用方提示。
+ */
+async function resolvePersonTokens(env, tokens) {
+    const map = new Map();
+    const unique = [...new Set(tokens.map((token) => String(token).trim()).filter((token) => token !== ''))];
+    if (unique.length === 0)
+        return map;
+    const idLike = unique.filter((token) => /^\d{8,}$/.test(token));
+    const nameLike = unique.filter((token) => !/^\d{8,}$/.test(token));
+    if (idLike.length > 0) {
+        const names = await resolveEmployeeNames(env, idLike);
+        for (const id of idLike)
+            map.set(id, { id, name: names.get(id) ?? id });
+    }
+    if (nameLike.length > 0) {
+        try {
+            const { hrmEmployeeOperations } = await import('../../../hrm/operations/employee.js');
+            const query = hrmEmployeeOperations.find((operation) => operation.name === 'hrm.employee.query');
+            for (const name of nameLike) {
+                if (!query)
+                    break;
+                const found = await query.handler({ keyword: name, pageSize: 10 }, env).catch(() => null);
+                const rows = (found?.data?.rows ?? []);
+                const exact = rows.find((row) => String(row.name ?? '').trim() === name);
+                const hit = exact ?? (rows.length === 1 ? rows[0] : undefined);
+                const id = String(hit?.id ?? '').trim();
+                if (id === '')
+                    continue;
+                map.set(name, { id, name: String(hit?.name ?? name) });
+            }
+        }
+        catch {
+            // 查不到就保持未解析，由调用方给出 warning
+        }
+    }
+    return map;
+}
+/**
+ * 「召集人 / 联系人」的缺省值 = **当前登录人**（2026-10-31 用户要求）。
+ *
+ * ⛔ 背景：以前这两个字段只有调用方显式传 `caller` / `contacter` 才写值。换一个账号用
+ * （"其他人使用"）时就是空的 —— 流程单上「召集人」「联系人」整块空白，表里看不出谁召集的，
+ * 邀请函也整段落成【待补充】。默认"自己召集、自己联系"才符合建会的常识。
+ *
+ * ⛔ 只有**能查到姓名**才返回：Employee 浏览按钮认的是员工 id，在不一致的租户（userId ≠ 员工 id）
+ * 里硬填会被工作流判成 `NEEDS_CONFIRMATION`，**提交直接卡住** —— 所以查不到宁可留空 +
+ * 提示调用方显式传，也不猜。
+ */
+export async function resolveSelfPerson(env) {
+    let session = null;
+    try {
+        session = await env.host?.getSession?.();
+    }
+    catch {
+        return null;
+    }
+    const id = String(session?.userId ?? '').trim();
+    if (id === '' || id === 'unknown')
+        return null;
+    const names = await resolveEmployeeNames(env, [id]);
+    const name = String(names.get(id) ?? '').trim();
+    if (name === '')
+        return null;
+    return { id, name };
+}
+/**
+ * 「召集人 / 联系人」缺省补齐（纯函数，便于测试）：**只补没传的那个字段**，
+ * 显式传了就以传的为准（替他人建会 / 指定别的联系人时不覆盖）。
+ */
+export function applySelfPersonDefaults(args, self) {
+    const filled = [];
+    const missing = ['caller', 'contacter']
+        .filter((field) => String(args[field] ?? '').trim() === '');
+    if (missing.length === 0)
+        return { filled, warning: '' };
+    if (!self) {
+        // 两个都缺才算问题：只缺一个（比如只指定了召集人）不提示，交给正常流程。
+        return {
+            filled,
+            warning: missing.length === 2
+                ? '⚠️ 没能确认当前登录用户对应的员工 ——「召集人」「联系人」会留空，'
+                    + '请显式传 caller / contacter（员工 id 或姓名）。'
+                : '',
+        };
+    }
+    for (const field of missing) {
+        args[field] = self.id;
+        filled.push({ field, id: self.id, name: self.name });
+    }
+    return { filled, warning: '' };
+}
+/**
+ * 拆「会议室」入参的三种常见写法：`123456`（id）、`会议室名`、`会议室名(123456)`。
+ *
+ * ⛔ 2026-10-31 真机事故：以前只把**纯数字**当房间 id，其它一律按"名称"原样丢给表单。
+ * 于是「测试会议室1」这种（用户实际最常说的写法）**既不查存在性、也不查占用**，
+ * 直接进确认摘要 —— 用户到流程页面提交时才被打回，或更糟：占用的房间被当成可用。
+ */
+export function parseRoomRef(input) {
+    const text = String(input ?? '').trim();
+    if (!text)
+        return {};
+    const withId = /^(.*?)[（(]\s*(\d{4,})\s*[)）]$/.exec(text);
+    if (withId) {
+        const name = withId[1].trim();
+        const id = withId[2];
+        return name ? { id, name } : { id };
+    }
+    if (/^\d+$/.test(text))
+        return { id: text };
+    return { name: text };
+}
+/** 把 address 入参解析成会议室台账里的真实记录（id / 名称 / 名称(id) 都能认）。 */
+export async function resolveAddressRoom(env, input) {
     const text = String(input ?? '').trim();
     if (!text)
         return null;
+    const ref = parseRoomRef(text);
     const { loadRooms } = await import('./room-recommend.js');
+    let rooms = [];
     try {
-        const { rooms } = await loadRooms(env, {});
-        const byId = rooms.find((room) => room.id === text);
-        if (byId)
-            return { id: byId.id, name: byId.name };
-        const byName = rooms.find((room) => room.name === text);
-        if (byName)
-            return { id: byName.id, name: byName.name };
+        rooms = (await loadRooms(env, {})).rooms;
     }
     catch {
-        // 缓存读不到就退到详情
+        // 台账读不到 ≠ 房间不存在：标记出来，让调用方不要据此判死
+        return { id: ref.id ?? '', name: ref.name ?? text, status: 'unknown', lookupFailed: true };
+    }
+    const hit = (ref.id ? rooms.find((room) => room.id === ref.id) : undefined)
+        ?? (ref.name ? rooms.find((room) => room.name === ref.name) : undefined);
+    if (hit)
+        return { id: hit.id, name: hit.name, status: hit.status, statusText: hit.statusText };
+    // 纯 id 且台账里没有（刚建/缓存旧）→ 保留 id 继续走，别拦住
+    if (ref.id)
+        return { id: ref.id, name: ref.name ?? '', status: 'unknown' };
+    return null;
+}
+/** 会议室 id → {id,name}（优先会议室缓存，缓存没有就查一次详情）。 */
+async function resolveRoomValue(env, input) {
+    const text = String(input ?? '').trim();
+    if (!text)
+        return null;
+    const resolved = await resolveAddressRoom(env, text).catch(() => null);
+    if (resolved?.id && !resolved.lookupFailed) {
+        return { id: resolved.id, name: resolved.name || resolved.id };
     }
-    if (/^\d+$/.test(text)) {
+    const ref = parseRoomRef(text);
+    if (ref.id) {
         try {
             const { getMeetingOperation } = await import('../registry.js');
-            const detail = await getMeetingOperation('meeting.eb.room.detail').handler({ id: text }, env);
+            const detail = await getMeetingOperation('meeting.eb.room.detail').handler({ id: ref.id }, env);
             const main = detail?.data?.mainTable ?? detail?.data?.data?.mainTable ?? {};
-            const name = String(main.room_name ?? '').trim();
+            const name = String(main.room_name ?? '').trim() || ref.name || '';
             if (name)
-                return { id: text, name };
+                return { id: ref.id, name };
         }
         catch {
             // 详情也拿不到就只传 id
         }
-        return { id: text, name: text };
+        return { id: ref.id, name: ref.name || ref.id };
     }
     return null;
 }
@@ -129,15 +273,20 @@ async function resolveRoomValue(env, input) {
  * getRelateData 里匹配，匹配不到就返回 NEEDS_CONFIRMATION（"无法唯一解析的选项"）——
  * 看起来像"流程建会走不通"，其实是值格式不对。这里统一补成对象。
  */
-async function shapeBrowserValues(env, values) {
+export 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 = [];
@@ -149,45 +298,633 @@ async function shapeBrowserValues(env, values) {
         idPool.push(...ids);
     }
     if (idPool.length > 0) {
-        const names = await resolveEmployeeNames(env, idPool);
-        const toObject = (id) => ({ id, name: names.get(id) ?? id });
+        const people = await resolvePersonTokens(env, idPool);
+        const toObject = (token) => people.get(token) ?? { id: token, name: token };
+        const toName = (token) => people.get(token)?.name ?? token;
         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);
+        }
+        // 解析不出员工的（同名歧义 / 花名册里没有）要点名，别让表单静默留空
+        const unresolved = [...new Set(idPool)].filter((token) => !people.has(token));
+        if (unresolved.length > 0) {
+            notes.push(`⚠️ 有 ${unresolved.length} 个人员没解析到员工：${unresolved.join('、')} —— `
+                + '表单里的「参会人员/召集人/联系人」可能显示不出来。请改传员工 id，或确认姓名与花名册完全一致。');
+        }
+    }
+    // 参会客户（CustomerComponent 客户浏览按钮）：与人员浏览按钮同形态 —— `[{id,name}]`。
+    // 服务端按 id 认客户，name 只用于列表显示，所以只有 id 时也照样提交（不留空行）。
+    if (shaped.crm_members !== undefined && shaped.crm_members !== '') {
+        const rows = [];
+        const push = (idRaw, nameRaw) => {
+            const id = String(idRaw ?? '').trim();
+            const name = String(nameRaw ?? '').trim();
+            if (id === '' && name === '')
+                return;
+            rows.push({ id, name });
+        };
+        // 单个 token 的宽容写法：`客户名(客户id)` 取括号里的 id；纯数字（雪花 id）当 id；
+        // 其余一律当**客户名**（2026-10-31 修：以前把纯名称整串当 id，导致「只传客户名」这种
+        // 最自然的写法反被判 crm_name_required 拒掉）。
+        const pushToken = (tokenRaw) => {
+            const token = String(tokenRaw ?? '').trim();
+            if (token === '')
+                return;
+            const matched = token.match(/^(.*?)[（(]\s*([0-9A-Za-z_-]+)\s*[)）]$/);
+            if (matched) {
+                push(matched[2], matched[1]);
+                return;
+            }
+            if (/^\d{8,}$/.test(token)) {
+                push(token, '');
+                return;
+            }
+            push('', token);
+        };
+        const raw = shaped.crm_members;
+        if (Array.isArray(raw)) {
+            for (const item of raw) {
+                if (item && typeof item === 'object') {
+                    const obj = item;
+                    push(obj.id ?? obj.sjID ?? obj.customerId, obj.name ?? obj.mc);
+                }
+                else {
+                    // ⛔ 数组里的字符串**也要走 `名称(id)` 解析**（2026-10-31 实测漏了这一步：
+                    // `["客户名(123)"]` 被整串当成 id 提交，服务端认不出客户、静默存空）。
+                    // 同时容忍 `["c1, c2"]` 这种"一个元素里塞了多个"的写法。
+                    for (const token of String(item).split(/[,;，；]+/).map((one) => one.trim()).filter((one) => one !== '')) {
+                        pushToken(token);
+                    }
+                }
+            }
+        }
+        else if (typeof raw === 'object') {
+            const obj = raw;
+            push(obj.id ?? obj.sjID ?? obj.customerId, obj.name ?? obj.mc);
+        }
+        else {
+            // "id1,id2" 或 "客户A(123)" 混写
+            for (const token of String(raw).split(/[,;，；]+/).map((item) => item.trim()).filter((item) => item !== '')) {
+                pushToken(token);
+            }
+        }
+        if (rows.length > 0) {
+            // 只给了客户名、没给 id ⇒ 用 `crm.search` 按名称补 id（「只传客户名」是最常见的用法）。
+            // 查不到就报 `crm_not_found` 让人去确认名称，**不静默丢客户**。
+            const nameOnly = rows.filter((row) => row.id === '' && row.name !== '');
+            if (nameOnly.length > 0) {
+                try {
+                    const { getMeetingOperation } = await import('../registry.js');
+                    const search = getMeetingOperation('meeting.eb.crm.search');
+                    for (const row of nameOnly) {
+                        const found = await search.handler({ keyword: row.name, limit: 5 }, env).catch(() => null);
+                        const items = (found?.data?.items ?? []);
+                        const hit = items.find((item) => String(item?.name ?? '').trim() === row.name) ?? items[0];
+                        const id = String(hit?.customerId ?? '').trim();
+                        if (id === '')
+                            continue;
+                        row.id = id;
+                        const fullName = String(hit?.name ?? '').trim();
+                        if (fullName !== '')
+                            row.name = fullName;
+                    }
+                }
+                catch {
+                    // 查询失败按"查不到"处理，下面统一报错
+                }
+            }
+            const unresolved = rows.filter((row) => row.id === '');
+            if (unresolved.length > 0) {
+                throw meetingValidationError('crm_not_found', `参会客户有 ${unresolved.length} 个在 CRM 里查不到：${unresolved.map((row) => row.name).join('、')}。`
+                    + '请确认客户名称，或先到客户表建档；也可以改用「客户名(客户id)」或 `[{id,name}]` 传 crm_members。');
+            }
+            shaped.crm_members = rows;
+            readable.crm_members = rows.map((row) => row.name || row.id).join('、');
+            notes.push(`参会客户按客户浏览按钮格式提交：${rows.length} 个客户`);
+            /**
+             * ⛔ 只有 id、没有名称 ⇒ **必须拦住**（2026-10-31 真机实证）。
+             *
+             * 客户浏览按钮（`CustomerComponent`）写入时服务端按「名称」落 `dataOptions.content`，
+             * 只给 id 的写法提交后会**静默存成空值**（单据详情里 `参会客户` 是 ""，不报错、不告警）。
+             * 之前"服务端按 id 认客户"的说法是错的，用它就会悄悄丢数据。
+             * ⇒ 这里直接拒绝，并给出可用写法；客户名可从 `meeting.eb.crm.search` 的 `items[].name` 拿。
+             */
+            const missingNames = rows.filter((row) => row.name === '');
+            if (missingNames.length > 0) {
+                throw meetingValidationError('crm_name_required', `参会客户有 ${missingNames.length} 个只给了 id、没有客户名称：${missingNames.map((row) => row.id).join('、')}。`
+                    + '客户浏览按钮必须带名称才能写入（只给 id 会被服务端静默存成空值）。'
+                    + '请先用 `meeting.eb.crm.search` 按客户名查到 `{ customerId, name }`，'
+                    + '再以 `[{id,name}]` 或「客户名(客户id)」的形式传 `crm_members`。');
+            }
+        }
+        else {
+            delete shaped.crm_members;
+        }
+    }
+    // 其余标量字段（会议名称/开始时间/结束时间/会议内容/人数…）原样给邀请函用
+    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();
+}
+/**
+ * 「参会客户明细」明细表（2026-10-31 新增）。
+ *
+ * 结构：宿主表单里是一张明细表（真机 会议申请流程 = `uf_mt_work_chkhmx`，subFormId `1332370499762806784`），
+ * 列为 姓名/性别/职位/手机号码/备注。**subFormId 与列字段 id 各租户不同**，所以一律从
+ * `workflow.createForm` 的字段清单里按列名反查，不写死 id。
+ *
+ * ⛔ 明细字段只有在「发起节点布局」里摆上之后才会出现在 `fields` 里；没摆上（或摆在隐藏行）
+ * 时这里解析不到，必须如实告警，不能静默丢行。
+ */
+const CRM_DETAIL_COLUMNS = {
+    xm: ['姓名', '客户姓名', '参会人', '参会人姓名'],
+    xb: ['性别'],
+    zw: ['职位', '职务'],
+    sjhm: ['手机号码', '手机号', '手机', '电话', '联系电话'],
+    bz: ['备注', '说明'],
+};
+/** 从表单字段清单里认出「参会客户明细」那张表（判据：有「姓名」列，且得分最高）。 */
+export function resolveCrmDetailTarget(fields) {
+    const groups = new Map();
+    for (const field of fields) {
+        const sid = String(field.subFormId ?? '').trim();
+        if (!sid)
+            continue;
+        const list = groups.get(sid);
+        if (list)
+            list.push(field);
+        else
+            groups.set(sid, [field]);
+    }
+    let best = null;
+    for (const [subFormId, list] of groups) {
+        const columns = {};
+        const labels = {};
+        for (const [semantic, aliases] of Object.entries(CRM_DETAIL_COLUMNS)) {
+            const hit = list.find((field) => aliases.includes(normalizeFieldName(field.name)));
+            if (!hit)
+                continue;
+            columns[semantic] = hit.id;
+            labels[semantic] = hit.name;
+        }
+        // 没有「姓名」列的明细表（会议议题/会议服务…）一律不算
+        if (!columns.xm)
+            continue;
+        const score = Object.keys(columns).length + (columns.sjhm ? 1 : 0) + (columns.zw ? 1 : 0);
+        if (!best || score > best.score)
+            best = { subFormId, columns, labels, score };
+    }
+    return best ? { subFormId: best.subFormId, columns: best.columns, labels: best.labels } : null;
+}
+/**
+ * 从「会议名称/内容/备注」里认出用户明确点出的客户名（`客户：中国民航` / `客户是xx` / `参会客户为 xx`）。
+ *
+ * 存在的理由：模型最常见的跑偏是把客户名写进会议名称/内容就直接提交，`crm_members` 一个都没传，
+ * 最后「参会客户」浏览按钮是空的（2026-10-31 真机踩到）。这里只做**识别**，不替用户查 CRM 也不自动写入。
+ * 只认带分隔符或「是/为」的显式写法，避免把「客户需求/客户满意度」这类普通词当成客户名。
+ */
+export function detectCrmMentionInText(...texts) {
+    for (const text of texts) {
+        if (typeof text !== 'string')
+            continue;
+        const value = text.trim();
+        if (value === '')
+            continue;
+        const hit = /(?:参会|拜访|来访)?客户\s*(?:名称)?\s*(?:是|为|[:：])\s*([^\s,，。；;、）)]{2,40})/.exec(value);
+        if (hit?.[1])
+            return hit[1].trim();
+    }
+    return null;
+}
+/** 把调用方给的明细行统一成 `{xm,xb,zw,sjhm,bz}`（中英文键都认；姓名与手机号都空的行直接丢）。 */
+export function normalizeCrmDetailRows(raw) {
+    if (raw === undefined || raw === null || raw === '')
+        return [];
+    const list = Array.isArray(raw) ? raw : [raw];
+    const keyAlias = {
+        xm: 'xm', name: 'xm', customername: 'xm', 姓名: 'xm', 客户姓名: 'xm',
+        xb: 'xb', gender: 'xb', sex: 'xb', 性别: 'xb',
+        zw: 'zw', title: 'zw', position: 'zw', job: 'zw', 职位: 'zw', 职务: 'zw',
+        sjhm: 'sjhm', mobile: 'sjhm', phone: 'sjhm', tel: 'sjhm', 手机号码: 'sjhm', 手机号: 'sjhm', 电话: 'sjhm', 联系电话: 'sjhm',
+        bz: 'bz', remark: 'bz', note: 'bz', 备注: 'bz', 说明: 'bz',
+    };
+    const rows = [];
+    for (const item of list) {
+        if (item === undefined || item === null || typeof item !== 'object')
+            continue;
+        const row = {};
+        for (const [key, value] of Object.entries(item)) {
+            const semantic = keyAlias[String(key).trim().toLowerCase()] ?? keyAlias[String(key).trim()];
+            if (!semantic)
+                continue;
+            if (value === undefined || value === null)
+                continue;
+            const text = String(value).trim();
+            if (text === '')
+                continue;
+            row[semantic] = text;
+        }
+        if (!row.xm && !row.sjhm)
+            continue;
+        rows.push(row);
+    }
+    return rows;
+}
+/**
+ * 从 `crm_members` 入参里取出「客户 + 联系人」。
+ *
+ * 调用方通常把 `meeting.eb.crm.search` 的 `items` 原样传进来（`[{customerId,name,contacts:[…]}]`），
+ * 联系人信息就在里面；只传 id/名称时 contacts 为空，由 `resolveAutoCrmDetailRows` 再去查。
+ */
+export function crmMemberEntriesFromArgs(raw) {
+    const list = Array.isArray(raw) ? raw : (raw === undefined || raw === null || raw === '' ? [] : [raw]);
+    const out = [];
+    const push = (idRaw, nameRaw, contactsRaw) => {
+        const id = String(idRaw ?? '').trim();
+        const name = String(nameRaw ?? '').trim();
+        if (id === '' && name === '')
+            return;
+        const contacts = (Array.isArray(contactsRaw) ? contactsRaw : [])
+            .map((item) => {
+            const row = (item ?? {});
+            return {
+                name: String(row.name ?? row.xm ?? '').trim(),
+                mobile: String(row.mobile ?? row.sjhm ?? row.phone ?? '').trim(),
+                ...(String(row.dept ?? row.bm ?? '').trim() === ''
+                    ? {}
+                    : { dept: String(row.dept ?? row.bm).trim() }),
+            };
+        })
+            .filter((one) => one.name !== '' || one.mobile !== '');
+        out.push({ id: id === '' ? name : id, name, contacts });
+    };
+    for (const item of list) {
+        if (item && typeof item === 'object') {
+            const obj = item;
+            push(obj.customerId ?? obj.sjID ?? obj.id, obj.name ?? obj.mc, obj.contacts ?? obj.lxr);
+        }
+        else {
+            // `"客户名(123)"` / `"123"` 两种纯文本写法
+            const token = String(item).trim();
+            if (token === '')
+                continue;
+            const matched = token.match(/^(.*?)[（(]\s*([0-9A-Za-z_-]+)\s*[)）]$/);
+            if (matched)
+                push(matched[2], matched[1], undefined);
+            else
+                push(token, '', undefined);
+        }
+    }
+    return out;
+}
+/**
+ * 联系人 → 「参会客户明细」行（姓名 / 手机号 / 备注=部门）。
+ *
+ * ⛔ 2026-10-31 用户要求：「带出了三个联系人，为什么要让我选，不能直接代入到流程里吗」。
+ * 明细表本来就是一人一行，所以**全部带入**，不再纠结"选哪一位"；要只留某一位，
+ * 调用方显式传 `crm_member_details` 覆盖即可。
+ */
+export function crmContactsToDetailRows(entries) {
+    const rows = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        for (const contact of entry.contacts) {
+            const xm = contact.name.trim();
+            const sjhm = contact.mobile.trim();
+            if (xm === '' && sjhm === '')
+                continue;
+            const key = `${xm}|${sjhm}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const row = { xm: xm === '' ? sjhm : xm };
+            if (sjhm !== '')
+                row.sjhm = sjhm;
+            if (contact.dept && contact.dept.trim() !== '')
+                row.bz = `部门：${contact.dept.trim()}`;
+            rows.push(row);
+        }
+    }
+    return rows;
+}
+/**
+ * 把「已选客户」的联系人自动补成明细行：入参自带就用自带的，没带就回查一次 `crm.search`。
+ *
+ * 为什么回查：模型经常只把 `customerId/name` 传过来（把 contacts 丢了），
+ * 结果明细表空着、又反过来问用户"联系人是谁"——多一轮对话，用户明确说不要这样。
+ */
+async function resolveAutoCrmDetailRows(env, raw) {
+    const entries = crmMemberEntriesFromArgs(raw);
+    const missing = [];
+    /**
+     * ⛔ 2026-10-31 修：以前只在「入参一个联系人都没带」时才回查，结果调用方（小E）只传了
+     * 用户挑中的那一位时，会议明细里就真只有一位 —— 而客户在 CRM 里其实有好几位。
+     * 用户的要求是「有几位就全带几位」，所以现在**一律回查一次，按 CRM 实时数据补全**（取并集，
+     * 已带的额外字段如性别/备注保留）。只有 CRM 也查不到时才留空。
+     */
+    if (entries.length > 0) {
+        try {
+            const { getMeetingOperation } = await import('../registry.js');
+            const search = getMeetingOperation('meeting.eb.crm.search');
+            for (const entry of entries) {
+                const keyword = (entry.name || entry.id).trim();
+                if (keyword === '') {
+                    missing.push(entry.id);
+                    continue;
+                }
+                const searchOnce = async (kw) => {
+                    const found = await search.handler({ keyword: kw, limit: 5 }, env).catch(() => null);
+                    const items = (found?.data?.items ?? []);
+                    const hit = items.find((item) => String(item?.customerId ?? '') === entry.id) ?? items[0];
+                    return (hit?.contacts ?? []);
+                };
+                let live = await searchOnce(keyword);
+                // 客户全名常带「--子公司、专项」后缀，动作流按全名可能一个都匹配不到；
+                // 这时退回「--」前的简称再搜一次（仍要按 customerId 认，别拿首个匹配凑数）。
+                if (live.length === 0 && keyword.includes('--')) {
+                    const short = keyword.split('--')[0].trim();
+                    if (short !== '')
+                        live = await searchOnce(short);
+                }
+                if (live.length === 0) {
+                    if (entry.contacts.length === 0)
+                        missing.push(entry.name || entry.id);
+                    continue;
+                }
+                const keyOf = (one) => `${String(one.name ?? '').trim()}|${String(one.mobile ?? '').trim()}`;
+                const merged = new Map();
+                for (const one of live)
+                    merged.set(keyOf(one), one);
+                for (const one of entry.contacts) {
+                    const key = keyOf(one);
+                    const base = merged.get(key);
+                    merged.set(key, base ? { ...base, ...one } : one);
+                }
+                entry.contacts = [...merged.values()];
+            }
+        }
+        catch {
+            // 查不到就沿用入参自带的联系人，由调用方按 warning 处理，不阻断建会
         }
     }
-    return { values: shaped, notes };
+    return {
+        rows: crmContactsToDetailRows(entries),
+        customers: entries.map((entry) => entry.name || entry.id).filter((one) => one !== ''),
+        missing,
+    };
 }
-/** 按别名把会议字段映射到表单字段 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 };
+}
+/**
+ * 把「表单字段 → 即将提交的值」渲染成人话 Markdown 表格，用于**提交前让用户核对**。
+ *
+ * ⛔ 2026-10-31 用户诉求：「为什么没有直接发起流程表单让我确认重填后让我点击提交」。
+ * 浏览器填单那条路走不通（浏览按钮不赋值，见 submit_mode 说明），所以改用"把要提交的内容
+ * 原样列出来给用户过一眼"来替代：值里的 `{id,name}` 一律显示姓名，数组顿号连接，空值写 `—`。
+ */
+/** 预览时要换成姓名的字段（表单里的中文名）。 */
+const PREVIEW_PERSON_FIELD_RE = /^(召集人|联系人|参会人员|会议创建人|主讲人|负责人|费用承担人)$/;
+/**
+ * 把要展示的 `main` 里「纯 id」的人员字段换成姓名。
+ *
+ * 为什么不直接指望上游已经是 `{id,name}`：`caller`/`contacter` 是 CLI 自己补的默认值，
+ * `mapFields` 之后仍是裸 id（只有 `hrm_members` 走过 `{id,name}` 成型）。不换的话
+ * 提交前的核对表会写成「联系人 | 4980990112251498198」—— 用户看到的是一串数字，
+ * 2026-10-31 就因此被投诉过"联系人怎么显示成 id"。
+ */
+async function decoratePreviewPersonNames(env, main, fields, known = new Map()) {
+    const targets = fields.filter((field) => PREVIEW_PERSON_FIELD_RE.test(String(field?.name ?? '').trim()));
+    if (targets.length === 0)
+        return main;
+    const ID_ONLY_RE = /^\d{8,}$/;
+    /** 这一格是不是「只有 id、没有真名」——字符串形态，或 `{id,name}` 里 name 为空/等于 id。 */
+    const missingNameId = (value) => {
+        if (typeof value === 'string')
+            return ID_ONLY_RE.test(value.trim()) ? value.trim() : null;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const obj = value;
+            const id = String(obj.id ?? '').trim();
+            const name = String(obj.name ?? '').trim();
+            if (id !== '' && (name === '' || name === id))
+                return id;
+        }
+        return null;
+    };
+    const ids = new Set();
+    for (const field of targets) {
+        const value = main[field.id];
+        const one = missingNameId(value);
+        if (one)
+            ids.add(one);
+        else if (Array.isArray(value))
+            for (const item of value) {
+                const hit = missingNameId(item);
+                if (hit)
+                    ids.add(hit);
+            }
+    }
+    if (ids.size === 0)
+        return main;
+    let names = new Map(known);
+    const unknown = [...ids].filter((id) => !names.has(id));
+    if (unknown.length > 0) {
+        try {
+            const resolved = await resolveEmployeeNames(env, unknown);
+            for (const [id, name] of resolved)
+                names.set(id, name);
+        }
+        catch {
+            // 查不到就用已知的（至少调用方显式给的姓名能显示）
+        }
+    }
+    if (names.size === 0)
+        return main;
+    const rename = (value) => {
+        const one = missingNameId(value);
+        if (one)
+            return names.get(one) ?? value;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const obj = value;
+            const id = String(obj.id ?? '').trim();
+            const name = names.get(id);
+            if (name)
+                return { ...obj, name };
+        }
+        return value;
+    };
+    const decorated = { ...main };
+    for (const field of targets) {
+        const value = decorated[field.id];
+        decorated[field.id] = Array.isArray(value) ? value.map(rename) : rename(value);
+    }
+    return decorated;
+}
+export function renderFormPreview(fields, main) {
+    const fmt = (value) => {
+        if (value === undefined || value === null)
+            return '—';
+        if (Array.isArray(value)) {
+            const parts = value.map((one) => fmt(one)).filter((one) => one !== '—');
+            return parts.length > 0 ? parts.join('、') : '—';
+        }
+        if (typeof value === 'object') {
+            const obj = value;
+            const name = String(obj.name ?? obj.mc ?? '').trim();
+            if (name !== '')
+                return name.replace(/\|/gu, '/');
+            const id = String(obj.id ?? obj.customerId ?? obj.sjID ?? '').trim();
+            return id === '' ? '—' : id;
+        }
+        const text = String(value).trim();
+        return text === '' ? '—' : text.replace(/\|/gu, '/').replace(/\r?\n/gu, ' ');
+    };
+    const lines = ['| 字段 | 值 |', '| --- | --- |'];
+    const known = new Set();
+    for (const field of fields) {
+        known.add(field.id);
+        if (!(field.id in main))
+            continue;
+        lines.push(`| ${String(field.name).replace(/\|/gu, '/')} | ${fmt(main[field.id])} |`);
+    }
+    // 字段清单里没有、但确实要提交的（datakey 直填的历史字段）也要列出来，别悄悄带上去
+    for (const [id, value] of Object.entries(main)) {
+        if (known.has(id))
+            continue;
+        lines.push(`| ${id} | ${fmt(value)} |`);
+    }
+    return lines.join('\n');
+}
+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 +952,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,37 +1041,138 @@ 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 时自动推荐「人+会议室都空闲」的时段。只出预览与确认票据，不提交。'
+        + '⚠️ 用户提到客户名（「客户是 X」）时**必须先** meeting.eb.crm.search {"keyword":"X"} 拿 customerId，'
+        + '再传 crm_members:[{id,name}]；只把客户名写进会议名称/内容，表单「参会客户」就是空的',
     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: '自定义会议地点' },
         hrm_members: { type: 'string', description: '参会人员（逗号分隔员工 id 或姓名，按流程表单要求）' },
         total_member: { type: 'number', description: '参会人数' },
-        caller: { type: 'string', description: '召集人' },
-        contacter: { type: 'string', description: '联系人' },
+        crm_members: {
+            oneOf: [{ type: 'string' }, { type: 'array', items: { oneOf: [{ type: 'string' }, { type: 'object' }] } }],
+            description: '参会客户：**必须带客户名称**，写法 `[{id,name}]` 或「客户名(客户id)」或逗号分隔的这两种。'
+                + '客户先从 `meeting.eb.crm.search` 按客户名查出（入参 custom_name，出参 items[].customerId / name），'
+                + '该查询**一次只回首个匹配** ⇒ exact=false 时必须先让用户确认客户名再写这个字段。'
+                + '⛔ 只给 id 不给名称会被拒绝（客户浏览按钮按名称落值，只给 id 会静默存成空）',
+        },
+        crm_member_count: { type: 'number', description: '应到客户数；不传则按 crm_members 条数自动算' },
+        crm_member_details: {
+            type: 'array',
+            description: '参会客户明细（宿主表单里的明细表，列 姓名/性别/职位/手机号码/备注）：'
+                + '每行 `{"xm":"张三","xb":"男","zw":"经理","sjhm":"138...","bz":""}`，也接受中文键（姓名/性别/职位/手机号码/备注）。'
+                + '列字段 id 由 CLI 从表单里按列名反查，不用传。'
+                + '⚠️ 该明细表必须在发起节点布局里（否则 CLI 会提示"表单里没有参会客户明细"并忽略这些行）'
+                + '⛔ 默认不生效：客户联系人由 CLI 按 CRM 全量自动带入，这里只在 crm_detail_mode:"only" 时才用来"只写这几位"',
+            items: { type: 'object' },
+        },
+        crm_detail_mode: {
+            type: 'string',
+            description: '明细行口径：不传（默认）= 按 CRM 把该客户**全部**联系人自动写入「参会客户明细」（一人一行，不用问用户选哪位）；'
+                + '传 "only" = 只写 crm_member_details 里点名的这几位',
+        },
+        caller: { type: 'string', description: '召集人（员工 id 或姓名）。缺省 = 当前登录人，不用传；只有指定别人当召集人才传' },
+        contacter: { type: 'string', description: '联系人（员工 id 或姓名）。缺省 = 当前登录人，不用传；只有指定别人当联系人才传' },
+        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 +1182,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 +1246,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 +1369,69 @@ 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;
+        };
+        // 「召集人 / 联系人」缺省 = 当前登录人（2026-10-31 用户要求）。
+        // ⛔ 以前只有调用方显式传值才写这两个字段：换个账号用（别人用）就整块空白，
+        // 流程单上「召集人」「联系人」空着、邀请函也落成【待补充】。现在默认取当前登录人，
+        // 只有显式传了别的值才以传的为准（各自独立兜底，只缺一个就只补一个）。
+        const needSelfPerson = String(args.caller ?? '').trim() === '' || String(args.contacter ?? '').trim() === '';
+        const autoPerson = applySelfPersonDefaults(args, needSelfPerson ? await resolveSelfPerson(env) : null);
+        const autoFilledPerson = autoPerson.filled;
+        const selfPersonWarning = autoPerson.warning;
+        // ⛔ 会议人数要含召集人：`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` 直接跳过整段 → "指定了一间被占用的房"照样往下走，用户到页面上才发现。
+        // ⛔ 2026-10-31 修：以前只有"纯数字 id"才查，传名称（用户最常说的「测试会议室1」）整段被跳过。
+        // 现在统一先解析成台账里的真实房间（id/名称/名称(id) 都认），再查占用 + 存在性 + 封存状态。
         const addressId = String(addressInput ?? '').trim();
-        const addressIsRoomId = /^\d+$/.test(addressId);
-        const roomConflictTask = (enrich && beginText && endText && addressIsRoomId)
+        // ④ 会议室闸门：与时间同理 —— 传了 address **不等于**用户确认过这间房。
+        // 只有 `roomConfirmed: true`（用户明确说了哪间，或在选项里点选后把 value 原样回传）才认；
+        // 否则返回房间选项让用户点。2026-10-30 同一事故：agent 把推荐房间写进确认摘要当定论。
+        const roomConfirmed = args.roomConfirmed === true;
+        const roomConflictTask = (enrich && beginText && endText && addressId !== '')
             ? (async () => {
+                const room = await resolveAddressRoom(env, addressId);
+                // 名称对不上任何房间 → 直接判"没这间房"，别把一串文本丢进表单等提交时才报错
+                if (!room)
+                    return { unresolved: true, input: addressId };
+                // 台账读失败 / 纯 id 台账里没有 → 没法判占用，但不拦（避免网络抖动被当成"房间不存在"）
+                if (!room.id || room.lookupFailed || room.status !== '0')
+                    return { room };
                 const { getMeetingOperation } = await import('../registry.js');
-                return getMeetingOperation('meeting.eb.conflict.room').handler({ beginDatetime: beginText, endDatetime: endText, address: addressId }, env);
-            })().catch(() => null)
+                const result = await getMeetingOperation('meeting.eb.conflict.room').handler({ beginDatetime: beginText, endDatetime: endText, address: room.id }, env);
+                return { room, ...(result?.data ?? {}) };
+            })().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,26 +1442,111 @@ 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) {
+        const roomConflictData = roomConflict;
+        const resolvedAddress = roomConflictData?.room ?? null;
+        const resolvedAddressId = resolvedAddress?.id || addressId;
+        const addressDisplay = resolvedAddress?.name || addressId;
+        // ①-a 名称对不上任何房间。
+        // ⛔ 2026-10-31 真机：以前这种会一路走到 AWAITING_CONFIRMATION，地点按纯文本塞进表单，
+        // 用户到流程页面提交时才被工作流打回「请按名称选择」—— 报错位置离真实原因太远。
+        if (roomConflictData?.unresolved === true) {
+            decisions.roomNotFound = { input: addressId, candidates: roomOptions.length };
+            if (roomOptions.length > 0)
+                decisions.roomOptions = roomOptions;
+            return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                status: 'NEEDS_SELECTION',
+                selectionType: 'room',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'R1' },
+                message: `没找到名为「${addressId}」的会议室（会议室台账里没有这个名字），本次**没有提交**。`
+                    + (roomOptions.length > 0
+                        ? `请从下面 ${roomOptions.length} 个在该时段空闲的会议室里选一间，或核对一下会议室名称`
+                        : '该时段也没有可用的空闲会议室，请改会议时间或改线上会议（allowNoRoom: true）'),
+                workflowPending: true,
+                options: roomOptions,
+                recommended: roomOptions[0]?.value ?? null,
+                roomNotFound: decisions.roomNotFound,
+                hint: '选定后把 value **整体**原样带回（含 roomConfirmed: true）；'
+                    + '核对名称可用 `meeting.eb.room.list` 看全量清单',
+            }, {
+                warnings: [
+                    `会议室「${addressId}」在台账里不存在，已拦下未提交。`,
+                    '⛔ 不要把它当成"用户指定的房间"写进确认摘要 —— 这间房根本没有被解析出来。',
+                ],
+            });
+        }
+        // ①-b 查到了，但已封存（status=1）：不能拿去建会。
+        if (resolvedAddress && resolvedAddress.status === '1') {
+            decisions.roomSealed = { id: resolvedAddress.id, name: resolvedAddress.name };
+            if (roomOptions.length > 0)
+                decisions.roomOptions = roomOptions;
+            return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
+                status: 'NEEDS_SELECTION',
+                selectionType: 'room',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'R1' },
+                message: `会议室「${resolvedAddress.name}」当前是**封存**状态（不可预约），本次**没有提交**。`
+                    + (roomOptions.length > 0
+                        ? '请改用下面空闲的会议室'
+                        : '该时段没有其它可用会议室，请改会议时间'),
+                workflowPending: true,
+                options: roomOptions,
+                recommended: roomOptions[0]?.value ?? null,
+                roomSealed: decisions.roomSealed,
+            }, {
+                warnings: [`会议室「${resolvedAddress.name}」（${resolvedAddress.id}）已封存，不可预约，已拦下未提交。`],
+            });
+        }
+        // 只有"用户已确认这间房"时才按占用拦截；未确认的只是候选，交给下面的选房分支处理。
+        if (addressInput && roomConfirmed && roomConflictData?.hasConflict === true) {
             const busy = Array.isArray(roomConflictData.conflicts) ? roomConflictData.conflicts : [];
             decisions.roomConflict = {
-                address: addressId,
+                address: resolvedAddressId,
+                addressName: addressDisplay,
                 hasConflict: true,
                 conflicts: busy,
                 verdict: roomConflictData.verdict ?? 'conflict',
@@ -439,15 +1556,18 @@ const ebMeetingCreateFlowPrepare = {
             return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
                 status: 'NEEDS_SELECTION',
                 selectionType: 'room_conflict',
-                message: `你指定的会议室在 ${beginText}~${endText} 已被占用（${busy.length} 条占用记录），`
-                    + '本次**没有提交**。请改用下面空闲的会议室，或调整会议时间',
+                ui: { component: 'choice', multiple: false, recommendedKey: 'R1' },
+                message: `你指定的会议室「${addressDisplay}」在 ${beginText}~${endText} 已被占用`
+                    + `（${busy.length} 条占用记录），本次**没有提交**。请改用下面空闲的会议室，或调整会议时间`,
+                workflowPending: true,
                 options: roomOptions,
                 recommended: roomOptions[0]?.value ?? null,
                 conflicts: busy,
+                roomConflict: decisions.roomConflict,
                 hint: '选定后把 value.id 作为 address 重新调用；要改时间就同时传新的 begin_datetime/end_datetime',
             }, {
                 warnings: [
-                    `会议室 ${addressId} 在该时段已有 ${busy.length} 条占用，已拦下未提交。`,
+                    `会议室「${addressDisplay}」（${resolvedAddressId}）在该时段已有 ${busy.length} 条占用，已拦下未提交。`,
                     roomOptions.length > 0
                         ? `已按人数/常用/空闲给出 ${roomOptions.length} 个替代会议室（R1 为首选）。`
                         : '该时段没有可替代的空闲会议室，建议调整会议时间或改线上会议（allowNoRoom: true）。',
@@ -466,18 +1586,54 @@ 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) {
+                // 用**解析后的真实房间 id** 去匹配候选：传名称时以前匹配不上，会被错标成"未解析的指定项"。
+                const hit = roomOptions.find((item) => String(item.value?.id) === resolvedAddressId);
+                const specified = hit
+                    ? { ...hit, label: `${hit.label}（你指定的，待确认）`, value: { ...hit.value, roomConfirmed: true } }
+                    : {
+                        key: 'R0',
+                        label: `${addressDisplay}（你指定的，待确认）`,
+                        value: { ...(resolvedAddressId ? { id: resolvedAddressId } : {}), name: addressDisplay, roomConfirmed: true },
+                        reason: '你传入的会议室，未提交、未确认',
+                    };
+                pickOptions = [specified, ...roomOptions.filter((item) => String(item.value?.id) !== resolvedAddressId)]
+                    .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
+                        ? `你传入的会议室「${addressDisplay}」**未经用户确认**（没带 roomConfirmed），已把它和其它候选一起列出来`
+                            + ' —— ⛔ 必须让用户在选项里点选，不要直接提交'
+                        : `未指定会议室，请从 ${pickOptions.length} 个候选里选择（已按人数/常用/时段占用排序）`,
+                    // 固化自动选的流程要带出来：调用方下一轮带 address 重调时不用再猜用的是哪条流程。
+                    workflowPending: true,
+                    options: pickOptions,
+                    recommended: pickOptions[0]?.value ?? null,
+                    hint: '选定后把 value **整体**原样带回（含 roomConfirmed: true）；'
+                        + '确实不需要会议室请传 allowNoRoom: true',
+                    ...conflictBrief,
                 }, {
                     warnings: [
-                        '未指定会议室：本次**没有**提交，也没有替用户挑房间。',
+                        addressInput
+                            ? `会议室「${addressDisplay}」未经用户确认：本次**没有**提交。`
+                            : '未指定会议室：本次**没有**提交，也没有替用户挑房间。',
                         '如需直接建会并沿用推荐，可传 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,41 +1657,218 @@ 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: `${addressDisplay}（你指定的，待确认）`,
+                value: { ...(resolvedAddressId ? { id: resolvedAddressId } : {}), name: addressDisplay, 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）：用户看确认摘要不能是一串数字。
+        // 名称/名称(id) 传进来时用解析出来的真实房间名，别再回显用户那串原文。
+        const confirmedAddressId = resolvedAddressId;
+        const confirmedAddressLabel = addressId === ''
+            ? ''
+            : (resolvedAddress?.name
+                || String(roomOptions.find((item) => String(item.value?.id ?? '') === confirmedAddressId)
+                    ?.value?.name ?? '')
+                || addressId);
+        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 crmMemberCount = (() => {
+            if (args.crm_member_count !== undefined && args.crm_member_count !== '')
+                return args.crm_member_count;
+            const raw = args.crm_members;
+            if (raw === undefined || raw === null || raw === '')
+                return undefined;
+            if (Array.isArray(raw))
+                return raw.length > 0 ? raw.length : undefined;
+            const text = String(raw).trim();
+            if (!text)
+                return undefined;
+            const count = text.split(/[,;，；]+/).map((item) => item.trim()).filter((item) => item !== '').length;
+            return count > 0 ? count : undefined;
+        })();
         const shaped = await shapeBrowserValues(env, {
             mt_name: args.mt_name,
             begin_datetime: args.begin_datetime,
@@ -545,6 +1878,8 @@ const ebMeetingCreateFlowPrepare = {
             customize_address: args.customize_address,
             hrm_members: args.hrm_members,
             total_member: args.total_member,
+            crm_members: args.crm_members,
+            ...(crmMemberCount === undefined ? {} : { crm_member_count: crmMemberCount }),
             caller: args.caller,
             contacter: args.contacter,
             other_remark: args.other_remark,
@@ -553,10 +1888,141 @@ 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 (autoFilledPerson.length > 0) {
+            const labels = autoFilledPerson.map((one) => `「${PERSON_FIELD_LABELS[one.field]}」`).join('');
+            warnings.push(`${labels}没有传值，已按**当前登录人**补齐：${autoFilledPerson[0].name}（${autoFilledPerson[0].id}）。`
+                + '要换成别人（例如替他人建会、指定别的联系人）请显式传 caller / contacter。');
+        }
+        else if (selfPersonWarning) {
+            warnings.push(selfPersonWarning);
+        }
+        // 固化自动选流程要留痕：调用方/用户能看到"用的是哪条、还有哪些可选"。
+        if (flowPickNote)
+            warnings.push(flowPickNote);
         for (const note of shaped.notes)
             warnings.push(note);
+        // 「提到客户却没传 crm_members」是最常见的一次跑偏：客户名被写进名称/内容就直接往下走，
+        // 结果「参会客户」浏览按钮是空的，单子看着正常、客户却没进表。这里点名提示。
+        const crmMentioned = detectCrmMentionInText(args.mt_name, args.mt_desc, args.other_remark);
+        if (crmMentioned && !args.crm_members) {
+            const hasCrmField = form.fields.some((field) => /参会客户/.test(String(field?.label ?? field?.name ?? field?.fieldName ?? '')));
+            warnings.push(`会议名称/内容里提到客户「${crmMentioned}」，但本次没传 crm_members`
+                + (hasCrmField
+                    ? '，该流程表单**有「参会客户」字段，现在会是空的**。请先 '
+                        + `meeting.eb.crm.search {"keyword":"${crmMentioned}"} 拿 items[].customerId，`
+                        + '再用 crm_members:[{id,name}] 重新提交（必须带客户名称）。'
+                    : '（该流程表单里没有「参会客户」字段，本条可忽略）。'));
+        }
+        // 传了客户就自动把**全部**联系人写成「参会客户明细」行（5 列：姓名/性别/职位/手机号码/备注），
+        // 不需要调用方去"选一位"（2026-10-31 用户纠正：有几位带几位）。
+        const crmMembersGiven = Array.isArray(args.crm_members)
+            ? args.crm_members.length > 0
+            : String(args.crm_members ?? '').trim() !== '';
+        // 「参会客户」是 `Ebuilder` 组件 —— **这是正常配置，别劝人去改表单**：同一张表单的「会议地点」
+        // 也是 Ebuilder，一直写得好好的。它落到会议表那一列由 **ESB 字段映射**负责（用户已配好），
+        // CLI 只负责把客户 id/名称写进流程单据，不再自己补写会议表。
+        if (crmMembersGiven) {
+            const crmFieldId = String(resolvedFields.crm_members ?? '').trim();
+            const crmField = form.fields.find((field) => String(field?.id ?? '') === crmFieldId);
+            const componentKey = String(crmField?.componentKey ?? '').toLowerCase();
+            if (crmField && componentKey !== '' && componentKey !== 'customer' && componentKey !== 'customercomponent') {
+                warnings.push(`「参会客户」字段（${crmFieldId}）是 ${crmField.componentKey} 组件：客户 id 与名称照常写进流程单据，`
+                    + '再由 ESB 的字段映射同步到会议表 —— 正常配置，不需要改表单。');
+            }
+        }
+        // 客户联系人：能自动带就**全部自动带进明细**，不再问用户"选哪一位"
+        // （2026-10-31 用户原话：「带出了三个联系人，为什么要让我选择，不能直接代入到流程里面去吗」）。
+        const providedCrmDetailRows = normalizeCrmDetailRows(args.crm_member_details);
+        // ⛔ 默认按 CRM **全量**补全；只有显式 crm_detail_mode:"only" 才只写用户点名的那几位。
+        //    2026-10-31 用户反馈「流程里只带出第一个联系人」——原因是调用方只把挑中的一位传了进来，
+        //    旧逻辑一看"入参已有联系人"就不再回查，于是明细永远只有一位。
+        const onlyDetailMode = String(args.crm_detail_mode ?? '').trim().toLowerCase() === 'only';
+        let crmDetailRows = onlyDetailMode ? providedCrmDetailRows : [];
+        if (crmMembersGiven && !onlyDetailMode) {
+            const detailTarget = resolveCrmDetailTarget(form.fields);
+            if (detailTarget) {
+                const auto = await resolveAutoCrmDetailRows(env, args.crm_members);
+                if (auto.rows.length > 0) {
+                    crmDetailRows = auto.rows;
+                    // 入参里显式给的额外列（性别/备注等）按姓名补回去，不全丢
+                    if (providedCrmDetailRows.length > 0) {
+                        const byName = new Map(providedCrmDetailRows.map((row) => [String(row.xm ?? '').trim(), row]));
+                        crmDetailRows = crmDetailRows.map((row) => {
+                            const given = byName.get(String(row.xm ?? '').trim());
+                            if (!given)
+                                return row;
+                            const merged = { ...row };
+                            for (const [key, value] of Object.entries(given)) {
+                                if (String(value ?? '').trim() !== '')
+                                    merged[key] = String(value);
+                            }
+                            return merged;
+                        });
+                    }
+                    warnings.push(`已自动把「${auto.customers.join('、')}」的 ${auto.rows.length} 位联系人写进「参会客户明细」：`
+                        + `${auto.rows.map((row) => `${row.xm}${row.sjhm ? ` ${row.sjhm}` : ''}`).join('、')}`
+                        + '（明细表本来就一人一行，不需要让用户挑）。确实只想要其中几位时，'
+                        + '传 crm_detail_mode:"only" 再配 crm_member_details 才覆盖本次自动带入。');
+                }
+                else if (auto.missing.length > 0) {
+                    warnings.push(`已写「参会客户」，但没能自动带出「${auto.missing.join('、')}」的联系人（CRM 里查不到）。`
+                        + '请把已查到的联系人直接告给用户核对；确实没有联系人时问一次姓名+手机号，'
+                        + '再以 crm_member_details:[{"xm":"张三","sjhm":"13800000000"}] 重新 prepare。');
+                }
+            }
+        }
+        // 参会客户明细（明细表）：行内用**列字段 id** 作 key，服务端按 id 认（名称列名各租户不同，不写死）。
+        let detailPayload;
+        if (crmDetailRows.length > 0) {
+            const target = resolveCrmDetailTarget(form.fields);
+            if (!target) {
+                warnings.push(`传了 crm_member_details（${crmDetailRows.length} 行），但该建会流程的**发起节点表单里没有「参会客户明细」明细表**`
+                    + '（或它被摆在隐藏行上），明细无法写入，已忽略这些行；主表的「参会客户」照常写入。');
+            }
+            else {
+                detailPayload = {
+                    [target.subFormId]: crmDetailRows.map((row) => {
+                        const line = {};
+                        for (const [semantic, fieldId] of Object.entries(target.columns)) {
+                            const value = row[semantic];
+                            if (value !== undefined && value !== '')
+                                line[fieldId] = value;
+                        }
+                        return line;
+                    }),
+                };
+                warnings.push(`参会客户明细：${crmDetailRows.length} 行写入明细表 ${target.subFormId}`
+                    + `（列：${Object.values(target.labels).join('/')}）`);
+            }
+        }
+        // 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,20 +2033,39 @@ 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 以为还需要额外补字段。
+        // crm_member_count 同理：它是**按客户条数自动派生**的（用户没手填），表单没有「应到客户数」
+        // 时静默忽略即可 —— 列出来会让 agent 以为要再补一个字段。
+        const unmappedReal = unmapped.filter((name) => name !== 'mt_name' && name !== 'crm_member_count');
+        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）」）。');
         }
+        // 客户 id 随凭证带到 apply：默认只用于邀请函/回显，**不再补写会议表**（那边由 ESB 字段映射负责）。
+        const crmPatchIds = (Array.isArray(shaped.values.crm_members) ? shaped.values.crm_members : [])
+            .map((row) => String(row?.id ?? '').trim())
+            .filter((id) => id !== '');
         const session = await env.host.getSession();
         const continuation = await env.continuation.issue({
             operation: 'meeting.eb.meeting.create.flow.apply',
@@ -591,10 +2076,22 @@ const ebMeetingCreateFlowPrepare = {
                 workflowId,
                 requestName: String(args.mt_name),
                 mtName: String(args.mt_name),
-                data: { main },
+                data: { main, ...(detailPayload ? { details: detailPayload } : {}) },
                 surfaceContinuation: form.continuation,
+                // 供 apply 在「会议还没生成」时按申请单信息预生成邀请函（预置函）
+                invitationFields: shaped.readable,
+                // 提交后回显要用「字段名 → 值」，字段清单先存下来（apply 阶段拿不到 createForm 结果）
+                fieldLabels: form.fields.map((field) => ({ id: String(field.id), name: String(field.name) })),
+                // 已确认的「人员 id → 姓名」，供 apply 回显时把裸 id 换成姓名
+                ...(autoFilledPerson.length > 0
+                    ? { personLabels: Object.fromEntries(autoFilledPerson.map((one) => [one.id, one.name])) }
+                    : {}),
+                // 会议记录的客户要靠 apply 补写（表单「参会客户」是 Ebuilder，单据↔会议表不同步）
+                ...(crmPatchIds.length > 0
+                    ? { crmPatch: { ids: crmPatchIds, count: crmMemberCount === undefined ? crmPatchIds.length : crmMemberCount } }
+                    : {}),
             },
-            fingerprint: JSON.stringify({ workflowId, main }),
+            fingerprint: JSON.stringify({ workflowId, main, ...(detailPayload ? { details: detailPayload } : {}) }),
         }, 10 * 60 * 1000);
         return meetingSuccess('meeting.eb.meeting.create.flow.prepare', {
             status: 'AWAITING_CONFIRMATION',
@@ -602,9 +2099,23 @@ 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 },
+                // 人话版「即将提交的内容」—— 提交前必须先贴给用户核对（见 SKILL 建会章节）。
+                formPreview: renderFormPreview(form.fields, await decoratePreviewPersonNames(env, main, form.fields, new Map(autoFilledPerson.map((one) => [one.id, one.name])))),
+                // 召集人/联系人是不是"替用户默认填的"要说清楚，用户才知道能不能改。
+                ...(autoFilledPerson.length > 0
+                    ? {
+                        autoFilled: Object.fromEntries(autoFilledPerson.map((one) => [PERSON_FIELD_LABELS[one.field], `${one.name}(${one.id})`])),
+                    }
+                    : {}),
+                ...(detailPayload
+                    ? { detailRows: { subFormId: Object.keys(detailPayload)[0], count: crmDetailRows.length, rows: crmDetailRows } }
+                    : {}),
                 formFieldCount: form.fields.length,
                 ...(Object.keys(decisions).length > 0 ? { decisions } : {}),
             },
@@ -613,6 +2124,123 @@ const ebMeetingCreateFlowPrepare = {
         }, warnings.length > 0 ? { warnings } : {});
     },
 };
+/**
+ * 补写客户后的观察窗（毫秒）—— 每一轮「写 → 等 → 回读」，被覆盖就再补一次。
+ * 会议刚生成时 ESB 会异步整行写主表，覆盖掉刚补的 `crm_members`。
+ */
+const CRM_PATCH_SETTLE_MS = [4000, 6000];
+/**
+ * 把「参会客户」补写进**会议记录**（会议表 `crm_members` 存客户 id，多客户逗号分隔）。
+ *
+ * ⛔ 2026-10-31 用户纠正「Ebuilder 组件这个就是对的」—— 我之前判"组件错、要换回 Customer"是错的：
+ * 同一张表单的「会议地点」也是 Ebuilder，一直写得好好的；Ebuilder 就是吃 `{id,name}` 的浏览按钮。
+ * 真正的原因是**流程单据 → 会议表的字段映射不覆盖「参会客户」**：单据里客户关联正常
+ * （`workflow.detail` 的 fieldValues 有「名(id)」），会议记录 `crm_members` 却一直是空
+ * ⇒ 邀请函「客户单位」、客户统计、会议详情全拿不到客户。
+ *
+ * 会议表本身是 eBuilder 表单，可以绕过流程映射直接 `updateFormData/change_meeting` 写。
+ * 写接口只回 `dataIds`（服务端对字段不做校验），所以**必须回读 `crm_members` 确认落库**。
+ */
+export async function patchMeetingCrmMembers(env, meetingId, ids, count, settleMsList = CRM_PATCH_SETTLE_MS) {
+    const list = ids.map((id) => String(id ?? '').trim()).filter((id) => id !== '');
+    if (String(meetingId).trim() === '' || list.length === 0) {
+        return { ok: false, error: '没有会议 id 或客户 id' };
+    }
+    const mainTable = {
+        id: String(meetingId).trim(),
+        operate_type: 'UPDATE',
+        crm_members: list.join(','),
+    };
+    const total = Number(count);
+    if (Number.isFinite(total) && total > 0)
+        mainTable.crm_total_member = String(total);
+    const write = async () => {
+        const session = await env.host.getSession();
+        await env.host.request({
+            method: 'POST',
+            path: `${EB_BASE}/updateFormData/change_meeting`,
+            query: { id: String(meetingId).trim() },
+            operation: 'meeting.eb.meeting.create.flow.apply',
+            body: writeBody(String(session.userId), { mainTable, details: {}, operateType: {} }),
+            acceptBusiness: ebBusinessSuccess,
+        });
+    };
+    const readBack = async () => {
+        const { getMeetingOperation } = await import('../registry.js');
+        const detail = getMeetingOperation('meeting.eb.meeting.detail');
+        const read = await detail.handler({ id: String(meetingId).trim() }, env);
+        return String(read?.data?.data?.crm_members ?? '').trim();
+    };
+    // ⛔ 写完立刻回读会「假成功」（2026-10-31 真机踩到）：会议刚生成时回执/占用等 ESB 还在异步写主表，
+    // 整行覆盖会把刚补的客户冲掉 —— 第一次回读非空、8 秒后再读又空了。所以每一轮都「写 → 等 → 再读」，
+    // 被覆盖就再补一次。两次等待合计 10s，只在真的带了客户时才有这段开销。
+    let lastError = '';
+    for (const settleMs of settleMsList) {
+        try {
+            await write();
+        }
+        catch (error) {
+            return { ok: false, error: String(error?.message ?? error).slice(0, 160) };
+        }
+        await new Promise((resolve) => setTimeout(resolve, settleMs));
+        try {
+            const value = await readBack();
+            if (value !== '')
+                return { ok: true, value };
+            lastError = '补写后回读 crm_members 仍为空（多半被会议初始化的后续写入覆盖了）';
+        }
+        catch (error) {
+            lastError = `补写成功但回读失败：${String(error?.message ?? error).slice(0, 120)}`;
+        }
+    }
+    return { ok: false, error: lastError };
+}
+/**
+ * 按申请单已知信息预生成邀请函（**预置函**）。
+ *
+ * 会议还没生成时也必须给一份：流程还在审批、或小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(),
+            // 客户单位（邀请函开头「尊敬的 XXX」）：建会时填了参会客户就直接带过去，
+            // 否则整句永远是【待补充】—— 用户看到的就是"客户明明填了，邀请函里却没有"。
+            extra: { guest_org: String(fields.crm_members ?? '').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',
@@ -625,6 +2253,13 @@ const ebMeetingCreateFlowApply = {
     inputSchema: schemaOf({
         continuation: { type: 'string', description: 'prepare 返回的确认票据（必填）' },
         confirm: { type: 'boolean', description: '必须显式传 true' },
+        submit_mode: {
+            type: 'string',
+            enum: ['direct', 'browser'],
+            description: '提交方式，默认 browser：在小e 里**弹出流程表单**，字段已预填，用户核对/修改后自己点提交。'
+                + 'direct = 直接写服务端（会议当场生成、邀请函用真实数据，但没有人工核对表单这一步）；'
+                + '只有用户明确说"不用我确认，直接建"时才传 direct',
+        },
         waitSeconds: { type: 'number', description: '提交后等待会议生成的最长秒数（默认 60，0 = 不等待）' },
     }, { required: ['continuation', 'confirm'] }),
     handler: async (args, env) => {
@@ -647,6 +2282,10 @@ const ebMeetingCreateFlowApply = {
         };
         const submitStartedAt = Date.now();
         const submit = getWorkflowOperation('workflow.createRequest');
+        // 默认走**浏览器填单**（2026-10-31 用户纠正）：小e 的填单页能按 id 把人员/客户带进去
+        // （`xiaoEUrlParamScalar` 对浏览按钮取 `id`），弹出表单让用户核对/修改/自己点提交才是要的体验。
+        // 传 submit_mode:"direct" 才改为服务端直提（会议当场生成，但没有人工确认这一步）。
+        const submitMode = String(args.submit_mode ?? 'browser').trim();
         const submitted = await submit.handler({
             // 工作流的入参名是 context（createForm 返回的 continuation 就是它的 context 句柄）
             context: payload.surfaceContinuation,
@@ -654,6 +2293,7 @@ const ebMeetingCreateFlowApply = {
             action: 'submit',
             requestName: payload.requestName,
             confirm: true,
+            ...(submitMode === 'browser' ? {} : { forceServerSubmit: true }),
         }, wfEnv);
         const submittedData = submitted?.data ?? {};
         const requestId = String(submittedData.requestId ?? submittedData.id ?? '').trim();
@@ -676,6 +2316,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 ?? [];
@@ -722,13 +2391,41 @@ const ebMeetingCreateFlowApply = {
             }
             timings.pollMs = Date.now() - pollStart;
         }
+        // 「参会客户」怎么落到会议表：**由 ESB 的字段映射负责**（流程单据 → 会议表 `ufd_crm_members_new`）。
+        // 2026-10-31 用户确认：「你发起流程后，字段映射是靠 ESB 来的，这个我已经配置好了」。
+        // ⛔ 所以 CLI **不再自己补写** `crm_members`：会议表里客户那一列的 dataKey 不是 `crm_members`
+        //    （写它既落不到页面，回读也永远为空），只会多出一条「客户没关联上」的假警报，把验收带偏。
+        //    真要回退老行为时置 WEAVER_MEETING_CRM_PATCH=1。
+        let crmLinked;
+        const crmPatch = payload?.crmPatch;
+        const crmPatchEnabled = process.env.WEAVER_MEETING_CRM_PATCH === '1';
+        if (meetingId && crmPatchEnabled && Array.isArray(crmPatch?.ids) && crmPatch.ids.length > 0) {
+            const patched = await patchMeetingCrmMembers(env, meetingId, crmPatch.ids, crmPatch.count);
+            crmLinked = {
+                ok: patched.ok,
+                requested: crmPatch.ids.length,
+                ...(patched.value ? { readBack: patched.value } : {}),
+                ...(patched.error ? { error: patched.error } : {}),
+            };
+            if (patched.ok) {
+                warnings.push(`「参会客户」已补写到会议记录（crm_members=${patched.value}）。`);
+            }
+            else {
+                warnings.push(`「参会客户」没有回读到（${patched.error ?? '未知原因'}）：当前走的是 CLI 手工补写（WEAVER_MEETING_CRM_PATCH=1），`
+                    + '不依赖 ESB 字段映射时才需要它。');
+            }
+        }
         let invitation = { pending: true };
         if (meetingId) {
             const invitationStart = Date.now();
             try {
                 const { getMeetingOperation } = await import('../registry.js');
                 const render = getMeetingOperation('meeting.invitation.render');
-                const rendered = await render.handler({ mtId: meetingId }, env);
+                const rendered = await render.handler({
+                    mtId: meetingId,
+                    // 同理：会议主表不存客户名，用建会时填的参会客户补「客户单位」
+                    extra: { guest_org: String(payload?.invitationFields?.crm_members ?? '').trim() },
+                }, env);
                 invitation = { pending: false, ...(rendered?.data ?? {}) };
                 timings.invitationMs = Date.now() - invitationStart;
             }
@@ -741,9 +2438,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',
@@ -752,6 +2456,11 @@ const ebMeetingCreateFlowApply = {
             requestId,
             requestName: payload.requestName,
             meetingId: meetingId || null,
+            // 参会客户有没有真的写进会议记录（表单侧是 Ebuilder，需 apply 补写；回读确认才算 ok）
+            ...(crmLinked ? { crmLinked } : {}),
+            // 提交后回显「实际提交了什么」：字段名 → 值（人员/客户显示姓名，不显示 id）。
+            // 用户要的就是"能看见内容"，替代走不通的浏览器填单核对。
+            submittedPreview: renderFormPreview(payload?.fieldLabels ?? [], await decoratePreviewPersonNames(env, (payload?.data?.main ?? {}), payload?.fieldLabels ?? [], new Map(Object.entries((payload?.personLabels ?? {}))))),
             invitation,
             result: submitted?.data ?? null,
         }, warnings.length > 0 ? { warnings } : {});
@@ -772,21 +2481,39 @@ const ebMeetingCreateFlowQuick = {
     resource: 'eb',
     method: 'meeting.eb.meeting.create.flow.quick',
     action: 'meeting.eb.meeting.create.flow.quick',
-    summary: '一步流程建会（prepare+apply 合并）：内部并行做会议室推荐/冲突检测/空闲时段，提交后自动出邀请函；多流程或需选择时不提交，返回选项',
+    summary: '一步流程建会（prepare+apply 合并）：内部并行做会议室推荐/冲突检测/空闲时段，默认**弹浏览器表单**给用户核对提交'
+        + '（submit_mode=browser，小e 里预填人员/客户后由用户点提交；非小e 环境会自动写服务端）；'
+        + '传 submit_mode=direct 才是服务端直提（拿 requestId + meetingId，会议当场生成、邀请函用真实数据）。'
+        + '多流程或需选择时不提交，返回选项。'
+        + '⚠️ 用户提到客户名时**必须先** meeting.eb.crm.search {"keyword":"X"} 拿 customerId 再传 crm_members:[{id,name}]；'
+        + '只把客户名写进会议名称/内容而不传 crm_members 会被直接拒绝（crm_member_required）。'
+        + '⛔ 不要用 submit_mode=browser —— 小e 填单页不给浏览按钮赋值，参会人员/参会客户会整段丢失',
     capability: 'eb.meeting',
     risk: 'high-risk-write',
     requiresConfirmation: true,
     inputSchema: schemaOf({
         mt_name: { type: 'string', description: '会议名称（必填）' },
-        begin_datetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填，yyyy-MM-dd HH:mm）' },
-        end_datetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填，yyyy-MM-dd HH:mm）' },
+        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: '自定义会议地点' },
         hrm_members: { type: 'string', description: '参会人员 id，逗号分隔' },
         total_member: { type: 'number', description: '参会人数' },
-        caller: { type: 'string', description: '召集人' },
-        contacter: { type: 'string', description: '联系人' },
+        caller: { type: 'string', description: '召集人（员工 id 或姓名）。缺省 = 当前登录人，不用传；只有指定别人当召集人才传' },
+        contacter: { type: 'string', description: '联系人（员工 id 或姓名）。缺省 = 当前登录人，不用传；只有指定别人当联系人才传' },
+        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 +2521,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,14 +2538,63 @@ 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 个有权限时直接发起',
+        },
+        crm_skip: {
+            type: 'boolean',
+            description: '显式声明「这次不填参会客户」。'
+                + '会议名称/内容里出现 `客户：X`、`客户是X` 这类字样却**没传 `crm_members`**时，'
+                + '一步建会会直接拒绝（crm_member_required）——确认这些字样不是要上会表的客户，才传 true',
+        },
+        submit_mode: {
+            type: 'string',
+            enum: ['direct', 'browser'],
+            description: '提交方式，默认 browser：在小e 里**弹出流程表单**（字段已预填含人员/客户），用户核对修改后自己点提交。'
+                + 'direct = 直接写服务端（会议当场生成、邀请函用真实数据，但没有人工核对表单这一步）；'
+                + '只有用户明确说"不用我确认，直接建"时才传 direct',
+        },
+    }, { required: ['mt_name', 'confirm'] }),
     handler: async (args, env) => {
         if (args.confirm !== true) {
             throw meetingValidationError('confirmation_required', '一步建会会直接提交流程，必须显式传 confirm=true；如只想看方案，请用 meeting.eb.meeting.create.flow.prepare');
         }
+        // 客户名写在名称/内容里、却没传 crm_members ⇒ 一步建会**直接拒绝**。
+        // quick 没有预览环节，放过去就是一张「参会客户」空着的单子（2026-10-31 真机踩到），
+        // 事后清理比在这儿拦一下贵得多。确认不需要填客户时传 crm_skip:true 放行。
+        const crmMentioned = detectCrmMentionInText(args.mt_name, args.mt_desc, args.other_remark);
+        const crmSkipped = args.crm_skip === true;
+        if (crmMentioned && !args.crm_members && !crmSkipped) {
+            throw meetingValidationError('crm_member_required', `会议名称/内容里提到客户「${crmMentioned}」，但没传 crm_members —— 提交后「参会客户」会是空的。`
+                + `先 meeting.eb.crm.search {"keyword":"${crmMentioned}"} 拿 items[].customerId，`
+                + '再把 crm_members:[{"id":"<customerId>","name":"<完整客户名>"}] 一起传'
+                + '（必须带名称，只给 id 会被静默存空）；确实不需要填参会客户就传 crm_skip:true。');
+        }
         const { getMeetingOperation } = await import('../registry.js');
         const prepareStartedAt = Date.now();
-        const prepared = await getMeetingOperation('meeting.eb.meeting.create.flow.prepare').handler({ ...args, confirm: undefined }, env);
+        const { submit_mode: _submitMode, confirm: _confirm, ...prepareArgs } = args;
+        const prepared = await getMeetingOperation('meeting.eb.meeting.create.flow.prepare').handler(
+        // submit_mode 只属于提交阶段，prepare 的 schema 不接受它（additionalProperties:false）
+        prepareArgs, env);
         if (prepared?.data?.status === 'NEEDS_SELECTION') {
             return prepared; // 让用户先选流程，不提交
         }
@@ -821,6 +2607,9 @@ const ebMeetingCreateFlowQuick = {
         const applied = await getMeetingOperation('meeting.eb.meeting.create.flow.apply').handler({
             continuation,
             confirm: true,
+            ...(args.submit_mode
+                ? { submit_mode: args.submit_mode }
+                : {}),
             ...(args.waitSeconds !== undefined ? { waitSeconds: args.waitSeconds } : {}),
         }, env);
         const warnings = [
@@ -833,6 +2622,12 @@ const ebMeetingCreateFlowQuick = {
             requestId: applied?.data?.requestId,
             meetingId: applied?.data?.meetingId ?? null,
             invitation: applied?.data?.invitation ?? null,
+            // 已提交内容回显（字段名 → 值），提交后可直接贴给用户看"到底填进去了什么"
+            submittedPreview: applied?.data?.submittedPreview ?? 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 +2640,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,