weaver-work-cli 0.1.38 → 0.1.40

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

@@ -7,6 +7,8 @@ import { meetingValidationError } from '../../errors.js';
 import { fetchEbAppSettings, findCommonFreeSlots } from './conflict.js';
 import { EB_BASE, ebBusinessSuccess, writeBody } from './factory.js';
 import { loadRooms, recommendRooms } from './room-recommend.js';
+import { dayOf, filterUsages, invalidateDayUsages, loadDayUsages } from './usage-cache.js';
+import { pickRememberedFlow, readFlowPick, rememberFlowPick } from './flow-memory.js';
 /**
  * 通过**流程**新建 EB 会议（`meeting.eb.meeting.create.flow`）。
  *
@@ -643,50 +645,55 @@ async function resolveAutoCrmDetailRows(env, raw) {
     const entries = crmMemberEntriesFromArgs(raw);
     const missing = [];
     /**
-     * ⛔ 2026-10-31 修：以前只在「入参一个联系人都没带」时才回查，结果调用方（小E）只传了
-     * 用户挑中的那一位时，会议明细里就真只有一位 —— 而客户在 CRM 里其实有好几位。
-     * 用户的要求是「有几位就全带几位」，所以现在**一律回查一次，按 CRM 实时数据补全**（取并集，
-     * 已带的额外字段如性别/备注保留）。只有 CRM 也查不到时才留空。
+     * ⛔ 2026-11-02 定案（用户确认）：
+     * - 入参**已经带了 `contacts`**（调用方查过 `crm.search`，用户也选定了客户）⇒ **直接用，不再回查**。
+     *   回查一次只会用客户名再模糊搜一遍，反而可能拿到**别的客户**的联系人。
+     * - 只有没带 `contacts` 时才回查，并且**必须按 `customerId` 精确匹配** ——
+     *   动作流是 like 模糊查，同一个词能命中一票近名客户（"中国民航"能回 10 个），
+     *   拿 `items[0]` 就等于把别人家的联系人写进这场会议。
      */
     if (entries.length > 0) {
         try {
             const { getMeetingOperation } = await import('../registry.js');
             const search = getMeetingOperation('meeting.eb.crm.search');
             for (const entry of entries) {
+                if (entry.contacts.length > 0)
+                    continue;
                 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);
+                /**
+                 * ⛔ 2026-11-02 实测：**同一个客户（sjID 相同），keyword 越"精确"，动作流回的 lxr 越少** ——
+                 *   「中国民航」→ 4 条原始（利明×2、胡老师、谷俊）；「…股份有限公司」→ 2 条；带 `--` 全名 → 1 条。
+                 *   是动作流把 keyword 掺进了 lxr 的关联过滤，ESB 那边要修。
+                 *   CLI 侧先兜住：由长到短几个候选各查一次，**取这批里联系人最多的那次**；
+                 *   但每次都**必须按 customerId 精确命中**（找不到就丢，绝不用 items[0] 兜底）——
+                 *   模糊查会命中一票近名客户，兜底就等于把别人家的联系人写进这场会议。
+                 */
+                const shortBase = keyword.split('--')[0].trim();
+                const stripped = shortBase
+                    .replace(/[（(][^）)]*[)）]/gu, '')
+                    .replace(/(股份有限公司|有限责任公司|集团有限公司|有限公司|集团|公司)$/u, '')
+                    .trim();
+                const candidates = [...new Set([keyword, shortBase, stripped, shortBase.slice(0, 4)].filter((one) => one !== ''))];
+                let live = [];
+                for (const candidate of candidates) {
+                    const found = await search.handler({ keyword: candidate, limit: 50 }, 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);
+                    const hit = entry.id !== ''
+                        ? items.find((item) => String(item?.customerId ?? '') === entry.id)
+                        : undefined;
+                    const contacts = (hit?.contacts ?? []);
+                    if (contacts.length > live.length)
+                        live = contacts;
                 }
                 if (live.length === 0) {
-                    if (entry.contacts.length === 0)
-                        missing.push(entry.name || entry.id);
+                    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()];
+                entry.contacts = live;
             }
         }
         catch {
@@ -965,7 +972,8 @@ export function normalizeWorkflowIds(raw) {
  *
  * ⛔ 固化不等于"不校验权限"：仍然逐个探测"当前账号能不能发起"，全部发起不了才回退应用设置。
  */
-const FIXED_FLOW_IDS = ['1325677244111462606', '1326190634427154474'];
+// 2026-11-03 用户指定：优先「会议申请流程」，北方大区那个放后面（权限探测照做，顺序只影响默认优先级）。
+const FIXED_FLOW_IDS = ['1326190634427154474', '1325677244111462606'];
 const FIXED_FLOW_PROFILES = [
     {
         host: 'www.e-cology.com.cn',
@@ -1208,7 +1216,15 @@ const ebMeetingCreateFlowPrepare = {
         },
         dateFrom: {
             type: 'string',
-            description: '没给具体时间时按哪一天推荐时段（yyyy-MM-dd；不传默认明天）',
+            description: '没给具体时间时按哪一天推荐时段（yyyy-MM-dd；不传默认明天）。'
+                + '⚠️ 用户说了「上午/下午/晚上」就必须同时传 time_slot —— 只传 dateFrom 会弹时段选择器让用户再选一次',
+        },
+        time_slot: {
+            type: 'string',
+            enum: ['上午', '早上', '下午', '晚上'],
+            description: '用户只说了「上午/下午/晚上」时传这个（配合 dateFrom）：'
+                + '上午/早上=09:00–12:00、下午=13:00–18:00、晚上=18:00–21:00，CLI 直接定下来、不再返回时段候选。'
+                + '⛔ 不要只传 dateFrom 就期待"让用户选时段"——用户已经说了时段就别再问',
         },
         durationMinutes: {
             type: 'number',
@@ -1227,8 +1243,10 @@ const ebMeetingCreateFlowPrepare = {
         flowChoice: {
             type: 'string',
             enum: ['auto', 'ask'],
-            description: '多个建会流程**都有发起权限**时怎么办：**默认（不传 / ask）= 返回选项让用户挑**；'
+            description: '多个建会流程**都有发起权限**时怎么办：默认（不传 / ask）= 返回选项让用户挑；'
                 + 'auto = 自动取优先级最高的那个（省一轮，但选错流程会漏字段，慎用）。'
+                + '有**流程记忆**（该账号上次成功用过的流程）且本次仍可发起时，默认直接沿用上次选择并留痕，'
+                + '不再弹选项；要强制回到"每次都问"才传 ask。'
                 + '只有 1 个有权限时不受此参数影响，CLI 直接发起',
         },
     }, { required: ['mt_name'] }),
@@ -1245,12 +1263,94 @@ const ebMeetingCreateFlowPrepare = {
         // enrich=false：只做"建会必需"的事（载入表单 + 填字段 + 提交），跳过会议室推荐/冲突检测/空闲时段。
         // 适用场景：人、时间、房间都已经确定，只想尽快把会建出来（可省掉 3 组额外请求与一次 ESB 调用）。
         const enrich = args.enrich !== false;
-        const beginText = String(args.begin_datetime ?? '').trim();
+        let beginText = String(args.begin_datetime ?? '').trim();
         let endText = String(args.end_datetime ?? '').trim();
+        /**
+         * 「上午/下午/晚上」→ 固定区间（2026-11-02 用户确认口径）：
+         *   上午 09:00–12:00、下午 13:00–18:00、晚上 18:00–21:00。
+         * 用户说了时段就等于拍了板，**不再返回候选让他挑**；
+         * 给了完整区间（"09:00 到 11:00"）就按给的，不做映射；只给开始时间的仍按 +1 小时补结束。
+         */
+        const TIME_SLOT_RANGES = {
+            上午: ['09:00', '12:00'],
+            早上: ['09:00', '12:00'],
+            下午: ['13:00', '18:00'],
+            晚上: ['18:00', '21:00'],
+        };
+        let slotConfirmed = false;
+        // ① 结构化入参 `time_slot`（推荐调用方用这个，比让模型拼中文串可靠）：
+        //    用户说"明天上午"就传 { dateFrom: '2026-11-03', time_slot: '上午' }。
+        const slotArg = String(args.time_slot ?? '').trim();
+        if (slotArg !== '' && !/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}/.test(beginText)) {
+            const range = TIME_SLOT_RANGES[slotArg];
+            const day = String(args.dateFrom ?? '').trim().slice(0, 10)
+                || beginText.slice(0, 10)
+                || tomorrowIso();
+            if (range && /^\d{4}-\d{2}-\d{2}$/.test(day)) {
+                beginText = `${day} ${range[0]}`;
+                endText = `${day} ${range[1]}`;
+                slotConfirmed = true;
+            }
+        }
+        // ①-b 老式写法兼容：有些调用方还会传 workStartHour/workEndHour（原本是"推荐时段范围"）。
+        //     2026-11-03 实测：模型用 {dateFrom, workStartHour:8, workEndHour:12} 表达"上午"，
+        //     结果 CLI 仍返回时段候选、用户被二次追问。这里按窗口**归一到固定时段**，不再问时间。
+        if (!slotConfirmed && !/\d{1,2}:\d{2}/.test(beginText)) {
+            const workStart = Number(args.workStartHour);
+            const workEnd = Number(args.workEndHour);
+            if (Number.isFinite(workStart) && Number.isFinite(workEnd) && workEnd > workStart) {
+                const slotName = workEnd <= 12 && workStart < 12
+                    ? '上午'
+                    : workStart >= 13 && workEnd <= 18
+                        ? '下午'
+                        : workStart >= 18
+                            ? '晚上'
+                            : '';
+                const range = slotName ? TIME_SLOT_RANGES[slotName] : undefined;
+                const day = String(args.dateFrom ?? '').trim().slice(0, 10)
+                    || beginText.slice(0, 10)
+                    || tomorrowIso();
+                if (range && /^\d{4}-\d{2}-\d{2}$/.test(day)) {
+                    beginText = `${day} ${range[0]}`;
+                    endText = `${day} ${range[1]}`;
+                    slotConfirmed = true;
+                }
+            }
+        }
+        // ② begin_datetime 里直接写中文（"2026-11-03 上午"）也认
+        const slotHit = beginText.match(/(\d{4}-\d{2}-\d{2})?\s*(上午|早上|下午|晚上)/u);
+        if (slotHit) {
+            const range = TIME_SLOT_RANGES[slotHit[2]];
+            const day = slotHit[1]
+                || beginText.slice(0, 10)
+                || String(args.dateFrom ?? '').trim().slice(0, 10)
+                || tomorrowIso();
+            const rest = beginText.replace(slotHit[0], '');
+            if (range && /^\d{4}-\d{2}-\d{2}$/.test(day) && !/\d{1,2}:\d{2}/.test(rest)) {
+                beginText = `${day} ${range[0]}`;
+                endText = `${day} ${range[1]}`;
+                slotConfirmed = true;
+            }
+        }
         const rawMembers = String(args.hrm_members ?? '')
             .split(/[,;，；\s]+/)
             .map((item) => item.trim())
             .filter((item) => item !== '');
+        /**
+         * 没传参会人 → **默认就是当前登录人**（2026-11-02 用户要求）。
+         * 以前这里空着会让调用方弹窗"请选择参会人"，但「我自己开的会」是最常见的情况，
+         * 多问一轮没必要；真要加人，用户会在后续对话里说。
+         */
+        let membersDefaulted = false;
+        if (rawMembers.length === 0) {
+            const self = await resolveSelfPerson(env);
+            if (self) {
+                rawMembers.push(self.id);
+                membersDefaulted = true;
+                // 写回入参：后面 shapeValues / mapFields 都读 args.hrm_members，不写回就进不了表单
+                args.hrm_members = rawMembers.join(',');
+            }
+        }
         // ⛔ 参会人冲突检测（conflict.member）与共同空闲时段（schedule.free）**要的是员工 id**，
         // 传姓名会被接口拒 —— 两路 Promise 都是 `.catch(() => null)`，于是"检测没跑"和"检测通过"
         // 在返回里长得一模一样，用户以为查过了（2026-10-30 真机：agent 传"易鹏"，两路全部静默跳过）。
@@ -1267,7 +1367,7 @@ const ebMeetingCreateFlowPrepare = {
         // CLI 当成"已定"直接进确认摘要，用户看到「时间：09:00–10:00」质问"谁决定的"。
         // 所以只有 `timeConfirmed: true`（用户原话明确给了时间，或用户在选项里点选后把 value 原样回传）
         // 才认这个时间；否则一律返回时段选项让用户点 —— 宁可多问一轮，也不替用户拍板。
-        const timeConfirmed = args.timeConfirmed === true;
+        const timeConfirmed = args.timeConfirmed === true || slotConfirmed;
         // ⛔ 2026-10-30 真机：agent 在用户只说"明天上午"时就自己塞了 workflowId，
         // 于是它脑内"流程已定"，回复里先讲流程再问时间（用户投诉顺序反了）。
         // 时间/地点闸门阶段流程根本没定 —— 这里只做提示，不阻断（用户可能确实点名了流程，
@@ -1392,15 +1492,33 @@ const ebMeetingCreateFlowPrepare = {
         const callerInMembers = callerToken !== '' && (rawMembers.includes(callerToken) || memberIds.includes(callerToken));
         const roomMemberCount = declaredTotal
             ?? (memberIds.length > 0 ? memberIds.length + (callerInMembers ? 0 : 1) : undefined);
+        // 有没有客户：决定要不要优先推接待类会议室（crm_members 可能是数组、"id,id" 或名称）
+        const hasCustomer = Array.isArray(args.crm_members)
+            ? args.crm_members.length > 0
+            : String(args.crm_members ?? '').trim() !== '';
+        // 全天占用缓存（2026-11-03 用户方案）：不带 address 条件一次拉当天全部会议室占用（~2s，
+        // 5 分钟 TTL），推荐 busy 判定与指定房间的占用检测**共用同一份**；同一天内改时间/换房间
+        // 不再打占用接口。提交成功后当天缓存立即作废（见提交成功处）。
+        const dayUsagesTask = (enrich && beginText && endText)
+            ? loadDayUsages(env, day)
+            : Promise.resolve(null);
         const roomTask = (enrich && beginText && endText)
-            ? recommendRooms(env, {
-                beginDatetime: beginText,
-                endDatetime: endText,
-                ...(roomMemberCount ? { memberCount: roomMemberCount } : {}),
-                // 建会是"要下单"的场景：宁可多一次请求也必须拿最新台账（24h 缓存会让刚导入的会议室看不到）。
-                refreshRooms: true,
-                topN: 3,
-            }).catch(noteFailure('会议室推荐'))
+            ? (async () => {
+                const usageData = await dayUsagesTask;
+                return recommendRooms(env, {
+                    beginDatetime: beginText,
+                    endDatetime: endText,
+                    ...(roomMemberCount ? { memberCount: roomMemberCount } : {}),
+                    // 带客户时优先接待类会议室（2026-11-02 用户口径：加了客户就推接待类）
+                    ...(hasCustomer ? { hasCustomer: true } : {}),
+                    // 2026-11-03 用户批准松绑：不再每次强制重拉台账（省 ~1s + 2 请求）。
+                    // 兜底在 recommendRooms 内部：24h 缓存凑不出候选时自动强制重拉一次再算；
+                    // 代价是刚导入的会议室在缓存期可能按名称查不到（按 id 指定不受影响）。
+                    topN: 3,
+                    // 占用走全天缓存（usageData 为 null 时 recommendRooms 内部自己查，行为不变）
+                    ...(usageData ? { dayUsages: usageData.rows } : {}),
+                });
+            })().catch(noteFailure('会议室推荐'))
             : Promise.resolve(null);
         // ⛔ 指定了会议室时，**单独查它在该时段是否已被占用**（query_roomusage_list）。
         // 以前 `!addressInput` 直接跳过整段 → "指定了一间被占用的房"照样往下走，用户到页面上才发现。
@@ -1420,6 +1538,21 @@ const ebMeetingCreateFlowPrepare = {
                 // 台账读失败 / 纯 id 台账里没有 → 没法判占用，但不拦（避免网络抖动被当成"房间不存在"）
                 if (!room.id || room.lookupFailed || room.status !== '0')
                     return { room };
+                // 优先走全天占用缓存本地过滤（2026-11-03）：与推荐共用一次拉取，0 额外请求。
+                // 缓存拉失败（dayUsagesTask reject 已被 noteFailure 吞成 null）→ 回退老的逐房查询，行为不变。
+                const usageData = await dayUsagesTask.catch(() => null);
+                if (usageData) {
+                    const conflicts = filterUsages(usageData.rows, { roomId: room.id, begin: beginText, end: endText })
+                        .map((usage) => ({ mtId: usage.mtId, begin: usage.start, end: usage.end }));
+                    return {
+                        room,
+                        hasConflict: conflicts.length > 0,
+                        conflicts,
+                        verdict: conflicts.length > 0 ? 'warn' : 'ok',
+                        requests: usageData.requests,
+                        usageFromCache: usageData.fromCache,
+                    };
+                }
                 const { getMeetingOperation } = await import('../registry.js');
                 const result = await getMeetingOperation('meeting.eb.conflict.room').handler({ beginDatetime: beginText, endDatetime: endText, address: room.id }, env);
                 return { room, ...(result?.data ?? {}) };
@@ -1764,66 +1897,83 @@ const ebMeetingCreateFlowPrepare = {
                     + '**不要**改用直连建会绕过流程管控。', { 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,
+                // 仍有多个可选 → 优先沿用**流程记忆**（2026-11-03 用户方案：这个人上次成功用过的流程），
+                // 记忆命中且本次仍可发起就直接用，不再打断用户（权限过滤照做，记忆只是默认值）。
+                // 传 flowChoice:'ask' 或记忆没命中 → 回到"让用户挑"。
+                const remembered = args.flowChoice === 'ask' ? null : await readFlowPick(env).catch(() => null);
+                const rememberedHit = pickRememberedFlow(launchable, remembered);
+                if (rememberedHit) {
+                    workflowId = rememberedHit.workflowId;
+                    const others = launchable
+                        .filter((probe) => probe.workflowId !== rememberedHit.workflowId)
+                        .map((probe) => (probe.name ? `${probe.name}（${probe.workflowId}）` : probe.workflowId));
+                    flowPickNote = `${sourceLabel}：当前账号可发起 ${launchable.length} 个建会流程，`
+                        + `已沿用你上次选的「${rememberedHit.name ?? rememberedHit.workflowId}」（${rememberedHit.workflowId}）发起`
+                        + ` —— 要换的话说一声${others.length > 0 ? `（其他可用：${others.join('、')}）` : ''}。`;
+                }
+                else {
+                    // 没有记忆可沿用 → 交给用户挑，不替用户决定（用户明确要求"以选择的方式"）
+                    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,
-                            timeConfirmed: true,
-                            ...(confirmedAddressId
-                                ? { address: confirmedAddressId, roomConfirmed: true }
-                                : {}),
+                            address: confirmedAddressId || null,
+                            addressName: confirmedAddressLabel || null,
+                            hrm_members: memberIds,
                         },
-                        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 ?? '无权限'}），已排除`),
-                    ],
-                });
+                        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) {
+            if (workflowId === '')
+                workflowId = launchable[0].workflowId;
+            if (launchable.length === 1 && candidates.length > 1 && flowPickNote === null) {
                 // 只有一条有权限 → 直接发起，但要说明"为什么没让你选"（其余流程是无权限，不是被忽略）。
                 const only = launchable[0];
                 flowPickNote = `${sourceLabel}：共 ${candidates.length} 个建会流程，当前账号只有`
                     + `「${only.name ?? only.workflowId}」（${only.workflowId}）有发起权限，已直接用它发起`;
             }
-            if (launchable.length > 1) {
+            if (launchable.length > 1 && flowPickNote === null) {
                 // 固化自用：多个可发起时按候选顺序自动取第一个 —— 但必须留痕说明"还有别的可用流程"，
                 // 不能默默替用户决定（2026-10-30：用户要的是"直接发起"，不是"什么都别告诉我"）。
                 const picked = launchable[0];
@@ -1947,7 +2097,9 @@ const ebMeetingCreateFlowPrepare = {
         if (crmMembersGiven && !onlyDetailMode) {
             const detailTarget = resolveCrmDetailTarget(form.fields);
             if (detailTarget) {
-                const auto = await resolveAutoCrmDetailRows(env, args.crm_members);
+                // 入参用**已解析成 [{id,name}] 的版本**：回查要按 customerId 精确命中，
+                // 只给名称的调用方式（`crm_members:"某客户"`）在这里已经没有 id 可用，会一条都拿不到。
+                const auto = await resolveAutoCrmDetailRows(env, shaped.values.crm_members ?? args.crm_members);
                 if (auto.rows.length > 0) {
                     crmDetailRows = auto.rows;
                     // 入参里显式给的额外列（性别/备注等）按姓名补回去，不全丢
@@ -2066,6 +2218,11 @@ const ebMeetingCreateFlowPrepare = {
         const crmPatchIds = (Array.isArray(shaped.values.crm_members) ? shaped.values.crm_members : [])
             .map((row) => String(row?.id ?? '').trim())
             .filter((id) => id !== '');
+        // 建群要用的要素随凭证带到 apply（2026-11-02 用户要求「发起流程时同步建群」）：
+        // 动作流的 hrmmembers **必须是员工 id 逗号串**，姓名它不认，所以这里只留 id。
+        const groupMemberIds = (Array.isArray(shaped.values.hrm_members) ? shaped.values.hrm_members : [])
+            .map((one) => String(one?.id ?? one ?? '').trim())
+            .filter((id) => id !== '');
         const session = await env.host.getSession();
         const continuation = await env.continuation.issue({
             operation: 'meeting.eb.meeting.create.flow.apply',
@@ -2074,8 +2231,9 @@ const ebMeetingCreateFlowPrepare = {
             userId: session.userId,
             payload: {
                 workflowId,
-                requestName: String(args.mt_name),
-                mtName: String(args.mt_name),
+                requestName: String(args.mt_name ?? args.mt_subject ?? ''),
+                mtName: String(args.mt_name ?? args.mt_subject ?? ''),
+                workflowName: String(form.workflowName ?? ''),
                 data: { main, ...(detailPayload ? { details: detailPayload } : {}) },
                 surfaceContinuation: form.continuation,
                 // 供 apply 在「会议还没生成」时按申请单信息预生成邀请函（预置函）
@@ -2090,6 +2248,13 @@ const ebMeetingCreateFlowPrepare = {
                 ...(crmPatchIds.length > 0
                     ? { crmPatch: { ids: crmPatchIds, count: crmMemberCount === undefined ? crmPatchIds.length : crmMemberCount } }
                     : {}),
+                // 建群要素：apply 拿到会议 id 后先建群、再把群 id 回写 imchat_groupid
+                groupChat: {
+                    memberIds: groupMemberIds,
+                    beginDatetime: String(shaped.values.begin_datetime ?? ''),
+                    endDatetime: String(shaped.values.end_datetime ?? ''),
+                    address: String(shaped.values.address ?? ''),
+                },
             },
             fingerprint: JSON.stringify({ workflowId, main, ...(detailPayload ? { details: detailPayload } : {}) }),
         }, 10 * 60 * 1000);
@@ -2102,7 +2267,7 @@ const ebMeetingCreateFlowPrepare = {
                 ...(flowPickNote
                     ? { workflowAutoPicked: { workflowId, source: resolved.source, note: flowPickNote } }
                     : {}),
-                requestName: String(args.mt_name),
+                requestName: String(args.mt_name ?? args.mt_subject ?? ''),
                 fieldMapping: mapped,
                 formData: { main },
                 // 人话版「即将提交的内容」—— 提交前必须先贴给用户核对（见 SKILL 建会章节）。
@@ -2323,6 +2488,44 @@ const ebMeetingCreateFlowApply = {
                 // 不能报错把整轮卡死（用户要的表单就在 finalMarkdown 里）。
                 // ⛔ 邀请函必须照给：它是预置函，按申请单已知信息生成，不依赖会议是否已生成。
                 const pre = await renderPreInvitation(payload, env);
+                // 建群：这一档服务端没有单据、也没有会议 id，只能先把群建出来（回写等会议生成后再补）。
+                // 用户口径是「发起流程时就同步建群」，表单都递到手上了，群该先建好。
+                let groupChat;
+                const groupPayload = payload?.groupChat;
+                if (groupPayload) {
+                    try {
+                        const { ensureMeetingGroupChat } = await import('./group-chat.js');
+                        groupChat = {
+                            ...(await ensureMeetingGroupChat(env, {
+                                meetingName: String(payload.mtName ?? ''),
+                                beginDatetime: String(groupPayload.beginDatetime ?? ''),
+                                endDatetime: String(groupPayload.endDatetime ?? ''),
+                                memberIds: (Array.isArray(groupPayload.memberIds) ? groupPayload.memberIds : []),
+                                ...(groupPayload.address ? { address: String(groupPayload.address) } : {}),
+                            })),
+                        };
+                    }
+                    catch (error) {
+                        groupChat = { ok: false, error: String(error?.message ?? error).slice(0, 200) };
+                    }
+                }
+                // 群建好了但还没有会议 id：落一条待绑记录（群 id + 工作流 + 时间），
+                // 用户点提交后用 lookupPending 按「流程单 → 会议」补绑，**不依赖会议名称**。
+                if (groupChat && groupChat.ok) {
+                    try {
+                        const { savePendingForm } = await import('./group-chat.js');
+                        await savePendingForm(env, {
+                            workflowId: String(payload.workflowId ?? ''),
+                            workflowName: String(payload.workflowName ?? ''),
+                            mtName: String(payload.mtName ?? ''),
+                            groupId: String(groupChat.groupId ?? ''),
+                            groupName: String(groupChat.groupName ?? ''),
+                        });
+                    }
+                    catch {
+                        // 落盘失败不影响输出表单；补绑时可改传 requestId
+                    }
+                }
                 return meetingSuccess('meeting.eb.meeting.create.flow.apply', {
                     status: 'BROWSER_FILL',
                     workflowId: payload.workflowId,
@@ -2332,13 +2535,24 @@ const ebMeetingCreateFlowApply = {
                     contextId: submittedData.contextId ?? null,
                     // 宿主要靠这段 <browsertool> 才能把表单拉到浏览器里填，必须原样透出
                     finalMarkdown: submittedData.finalMarkdown ?? null,
+                    // 与 finalMarkdown 相邻的硬提示：模型「以为 CLI 已经打开了表单」是这次翻车的直接原因
+                    finalMarkdownHint: '把 finalMarkdown 原样贴在回复最后（从 <browsertool> 到 </browsertool>，不包代码块）；'
+                        + '不贴这段＝用户看不到表单，也不能说"表单已打开"。',
                     message: String(submittedData.message ?? ''),
                     invitation: pre.invitation,
+                    ...(groupChat ? { groupChat } : {}),
                     timings: { submitMs: Date.now() - submitStartedAt, invitationMs: pre.ms },
                 }, {
                     warnings: [
                         '当前是小e 环境：本次**没有向服务端写入**，建会流程改由浏览器页面完成填单（见 finalMarkdown）。'
                             + '因此还没有 requestId / 会议 id，也**不能说"流程已提交"**。',
+                        ...(groupChat && groupChat.ok
+                            ? [`群聊已同步建好（群 id ${String(groupChat.groupId)}，群名 ${String(groupChat.groupName)}）：`
+                                    + '流程还没提交、没有会议 id，所以 imchat_groupid 暂时没回写；'
+                                    + '会议生成后再跑一次 meeting.eb.meeting.group.ensure（传 meetingId + groupId）绑定。']
+                            : groupChat
+                                ? [`群聊没建成功（${String(groupChat.error ?? '未知原因')}）：会议照常可以在页面里提交，群需要手工建或稍后重试。`]
+                                : []),
                         `邀请函已按申请单信息**预生成**（预置函，${String(pre.invitation.filePath ?? '见 filePath')}）：`
                             + '请下载后人工核对、自行发送；流程审批通过、会议生成后可用 mtId 再跑一次 meeting.invitation.render 拿完整字段版本。',
                         '⛔ 不要因为"没有 requestId / 没有会议 id"重复 apply —— 填单要在那个浏览器页面里点提交。',
@@ -2354,6 +2568,14 @@ const ebMeetingCreateFlowApply = {
                     : '服务端未返回 requestId，请查看 result 排查'), { submit: submittedData, missing });
         }
         const warnings = [];
+        // ── 提交成功后的收尾（都是 void 异步，不阻塞返回）──────────────────────
+        // ① 当天占用缓存作废：这场会已经占了房，不删的话 5 分钟内同房间的占用检测会漏判
+        //    （2026-11-03 用户方案：缓存只服务"提交前"的检测，提交即失效）。
+        const submitDay = dayOf(String(payload?.groupChat?.beginDatetime ?? ''));
+        if (submitDay !== '')
+            void invalidateDayUsages(env, submitDay).catch(() => undefined);
+        // ② 流程记忆：记住这次实际用的流程 —— 下次"多流程可发起"时默认沿用（2026-11-03 用户方案）。
+        void rememberFlowPick(env, String(payload?.workflowId ?? ''), typeof payload?.workflowName === 'string' ? payload.workflowName : undefined).catch(() => undefined);
         // 会议由流程/ESB 创建：提交后不一定立刻出现，轮询一下再决定要不要出邀请函。
         // 默认只等 20s：流程多走审批，干等会把"建个会"拖成好几分钟（用户 2026-10-28 反馈）；
         // 没等到就给 pending，让调用方稍后补邀请函。
@@ -2361,13 +2583,16 @@ const ebMeetingCreateFlowApply = {
         let meetingId = '';
         const timings = { submitMs: Date.now() - submitStartedAt };
         if (waitSeconds > 0) {
-            // 轮询策略：**先立即查一次**（多数情况下会议是同步生成的），没有就 5 秒后再查一次；
-            // 仍未生成说明还在审批，直接返回 pending —— 不再按 waitSeconds 死等（用户体感"建会好几分钟"多半是这里）。
+            // 轮询策略（2026-11-03 用户确认「还是要轮询」）：**先立即查一次**，之后按 0.5/1/2/4 秒加密连查——
+            // 审批多数几秒内通过，加密能早 3~4 秒拿到会议号（原来固定 0/5s 两查，命中最晚要等 5 秒）；
+            // 封顶 ~7.5s 仍未生成就返回 pending，不死等（审批中的会调用方稍后补邀请函）。
             const { getMeetingOperation } = await import('../registry.js');
             const list = getMeetingOperation('meeting.eb.meeting.list');
             const deadline = Date.now() + Math.min(waitSeconds, 30) * 1000;
             const pollStart = Date.now();
             let waited = 0;
+            let stepIndex = 0;
+            const pollSteps = [500, 1000, 2000, 4000];
             while (Date.now() <= deadline) {
                 try {
                     const page = await list.handler({ mt_name: payload.mtName, pageSize: 5 }, env);
@@ -2384,10 +2609,12 @@ const ebMeetingCreateFlowApply = {
                 catch {
                     // 查询失败不中断，继续按节奏重试
                 }
-                if (waited >= 5000)
-                    break; // 第二次仍未命中：不再等，交给调用方稍后补邀请函
-                await new Promise((resolve) => setTimeout(resolve, 5000));
-                waited += 5000;
+                if (waited >= 7500)
+                    break; // 0 + 0.5 + 1 + 2 + 4 秒五查仍未命中：还在审批，交给调用方稍后补邀请函
+                const step = pollSteps[Math.min(stepIndex, pollSteps.length - 1)];
+                stepIndex += 1;
+                await new Promise((resolve) => setTimeout(resolve, step));
+                waited += step;
             }
             timings.pollMs = Date.now() - pollStart;
         }
@@ -2415,6 +2642,42 @@ const ebMeetingCreateFlowApply = {
                     + '不依赖 ESB 字段映射时才需要它。');
             }
         }
+        // 「发起流程时同步建群」（2026-11-02 用户要求）：建群动作流一次做完「建群 + 群内发会议信息」，
+        // 但它的 responseData 是空对象、不回群 id ⇒ 建完按「群名 = 会议名称」反查，再回写 imchat_groupid。
+        // ⛔ 建群失败**不影响建会结果**：这里只记 warning，不抛错（会议已经建好了，群可以后补）。
+        let groupChat;
+        const groupPayload = payload?.groupChat;
+        if (groupPayload) {
+            const groupStart = Date.now();
+            try {
+                const { ensureMeetingGroupChat } = await import('./group-chat.js');
+                const group = await ensureMeetingGroupChat(env, {
+                    meetingName: String(payload.mtName ?? ''),
+                    beginDatetime: String(groupPayload.beginDatetime ?? ''),
+                    endDatetime: String(groupPayload.endDatetime ?? ''),
+                    memberIds: (Array.isArray(groupPayload.memberIds) ? groupPayload.memberIds : []),
+                    ...(groupPayload.address ? { address: String(groupPayload.address) } : {}),
+                    ...(meetingId ? { meetingId } : {}),
+                });
+                groupChat = { ...group };
+                if (group.ok && group.bound) {
+                    warnings.push(`已按会议同步建群「${group.groupName ?? payload.mtName}」（群 id ${group.groupId}），`
+                        + `并回写到会议记录 imchat_groupid${group.readBack ? `（回读 ${group.readBack}）` : ''}。`);
+                }
+                else if (group.ok) {
+                    warnings.push(`群已建好（群 id ${group.groupId}），但会议还没生成，暂时没法回写 imchat_groupid；`
+                        + '会议生成后传 meetingId+groupId 跑一次 meeting.eb.meeting.group.ensure 绑定即可。');
+                }
+                else {
+                    warnings.push(`群聊没建成功/没绑上（${group.error ?? '未知原因'}）：会议本身已建好，群可在 IM 里手工建，`
+                        + '再把群 id 传到 meeting.eb.meeting.group.ensure 的 groupId 绑定。');
+                }
+            }
+            catch (error) {
+                warnings.push(`建群异常（不影响建会）：${String(error?.message ?? error).slice(0, 200)}`);
+            }
+            timings.groupMs = Date.now() - groupStart;
+        }
         let invitation = { pending: true };
         if (meetingId) {
             const invitationStart = Date.now();
@@ -2458,6 +2721,8 @@ const ebMeetingCreateFlowApply = {
             meetingId: meetingId || null,
             // 参会客户有没有真的写进会议记录（表单侧是 Ebuilder，需 apply 补写；回读确认才算 ok）
             ...(crmLinked ? { crmLinked } : {}),
+            // 同步建的群（群 id / 群名 / 有没有回写 imchat_groupid）
+            ...(groupChat ? { groupChat } : {}),
             // 提交后回显「实际提交了什么」：字段名 → 值（人员/客户显示姓名，不显示 id）。
             // 用户要的就是"能看见内容"，替代走不通的浏览器填单核对。
             submittedPreview: renderFormPreview(payload?.fieldLabels ?? [], await decoratePreviewPersonNames(env, (payload?.data?.main ?? {}), payload?.fieldLabels ?? [], new Map(Object.entries((payload?.personLabels ?? {}))))),
@@ -2540,7 +2805,15 @@ const ebMeetingCreateFlowQuick = {
         },
         dateFrom: {
             type: 'string',
-            description: '没给具体时间时按哪一天推荐时段（yyyy-MM-dd；不传默认明天）',
+            description: '没给具体时间时按哪一天推荐时段（yyyy-MM-dd；不传默认明天）。'
+                + '⚠️ 用户说了「上午/下午/晚上」就必须同时传 time_slot —— 只传 dateFrom 会弹时段选择器让用户再选一次',
+        },
+        time_slot: {
+            type: 'string',
+            enum: ['上午', '早上', '下午', '晚上'],
+            description: '用户只说了「上午/下午/晚上」时传这个（配合 dateFrom）：'
+                + '上午/早上=09:00–12:00、下午=13:00–18:00、晚上=18:00–21:00，CLI 直接定下来、不再返回时段候选。'
+                + '⛔ 不要只传 dateFrom 就期待"让用户选时段"——用户已经说了时段就别再问',
         },
         durationMinutes: {
             type: 'number',
@@ -2558,7 +2831,8 @@ const ebMeetingCreateFlowQuick = {
             type: 'string',
             enum: ['auto', 'ask'],
             description: '多个建会流程**都有发起权限**时：默认（不传 / ask）= 返回选项让用户挑；'
-                + 'auto = 自动取优先级最高的。只有 1 个有权限时直接发起',
+                + 'auto = 自动取优先级最高的。有流程记忆（上次成功用过的流程）且仍可发起时默认沿用上次选择，'
+                + '传 ask 强制每次都问。只有 1 个有权限时直接发起',
         },
         crm_skip: {
             type: 'boolean',
@@ -2622,12 +2896,15 @@ const ebMeetingCreateFlowQuick = {
             requestId: applied?.data?.requestId,
             meetingId: applied?.data?.meetingId ?? null,
             invitation: applied?.data?.invitation ?? null,
+            // 同步建的群（群 id / 群名 / 有没有回写 imchat_groupid）
+            ...(applied?.data?.groupChat ? { groupChat: (applied?.data).groupChat } : {}),
             // 已提交内容回显（字段名 → 值），提交后可直接贴给用户看"到底填进去了什么"
             submittedPreview: applied?.data?.submittedPreview ?? null,
             // 小e 环境（BROWSER_FILL）不写服务端，表单靠这段 <browsertool> 在浏览器里填 —— 必须一起透出，
             // 否则宿主拿不到表单，用户看到的就是"提交了但没反应"。
             ...(applied?.data?.contextId ? { contextId: (applied?.data).contextId } : {}),
             ...(applied?.data?.finalMarkdown ? { finalMarkdown: (applied?.data).finalMarkdown } : {}),
+            ...(applied?.data?.finalMarkdownHint ? { finalMarkdownHint: (applied?.data).finalMarkdownHint } : {}),
             decisions: prepared?.data?.preview?.decisions ?? null,
             timings: {
                 ...(prepared?.data?.preview?.decisions?.timings ?? {}),