weaver-work-cli 0.1.32 → 0.1.36

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

@@ -71,10 +71,12 @@ function isNetworkError(error) {
  * 该缺陷曾导致 CLI 的 EB 读操作全线失败，并连带使 `meeting.env.detect` 的 EB 冒烟失败、
  * 环境被误判为 standard 版。
  */
-export function queryBody(userId, page) {
+export function queryBody(userId, page, mainTable) {
     return {
         datajson: {
-            mainTable: {},
+            // 传入字段即过滤条件（e-builder openApi 文档：getFormDataList 的传入字段挂 mainTable 节点）。
+            // 空对象 = 不过滤。
+            mainTable: mainTable ?? {},
             // ⚠️ 分页必须放在 body 的 pageInfo 里（值为字符串）：只放 URL query 时 EB 会忽略，
             // 恒定返回首页 10 条（2026-09-21 真机暴露：pageSize=60 仍只回 10 条）。
             ...(page ? { pageInfo: { pageNo: String(page.pageNo), pageSize: String(page.pageSize) } } : {}),
@@ -82,6 +84,27 @@ export function queryBody(userId, page) {
         },
     };
 }
+/**
+ * 模糊回退最多翻几页。EB 的 pageSize 不生效（恒定回 10 条），所以翻页数直接决定能覆盖多少数据。
+ * 环境变量 `WEAVER_MEETING_EB_FALLBACK_MAX_PAGES` 可覆盖，默认 30（≈300 条）。
+ */
+function readFallbackMaxPages() {
+    const raw = Number(process.env.WEAVER_MEETING_EB_FALLBACK_MAX_PAGES ?? '');
+    if (Number.isFinite(raw) && raw >= 1)
+        return Math.min(Math.floor(raw), 100);
+    return 30;
+}
+/** 从入参里挑出「服务端过滤字段」（mainTableParams），没传的不进 body。 */
+function pickMainTableFilters(args, names) {
+    const out = {};
+    for (const name of names ?? []) {
+        const value = args[name];
+        if (value === undefined || value === null || value === '')
+            continue;
+        out[name] = typeof value === 'string' ? value : String(value);
+    }
+    return out;
+}
 /** 详情接口 body（getFormDataByPk）：顶层 mainTable 传 id。 */
 function detailBody(userId, id) {
     return { datajson: { mainTable: { id }, header: { operator: userId } } };
@@ -138,11 +161,24 @@ function buildReadInputSchema(endpoint) {
         for (const param of endpoint.queryParams ?? []) {
             properties[param] = { type: 'string', description: `EB 筛选参数（URL 占位符名 ${param}）` };
         }
+        for (const param of endpoint.mainTableParams ?? []) {
+            properties[param] = {
+                type: 'string',
+                description: `按 ${param} 过滤（走 body datajson.mainTable，服务端**精确匹配**；`
+                    + `传部分词时服务端会返回 0 条，CLI 会自动翻页扫全量并按「包含」重新筛，结果一样是模糊的）`,
+            };
+        }
         properties.pageNo = { type: 'integer', minimum: 1, description: '页码，默认 1' };
         properties.pageSize = { type: 'integer', minimum: 1, maximum: 200, description: '每页条数，默认 20' };
         if (endpoint.countPk) {
             properties.withCount = { type: 'boolean', description: '是否先查总数（默认 true，条件与列表一致）' };
         }
+        if ((endpoint.mainTableParams ?? []).length > 0) {
+            properties.noFallback = {
+                type: 'boolean',
+                description: '跳过「模糊兜底」：服务端精确匹配不到时，不再翻页扫全量（默认 false=会扫，保证部分词也能查到）',
+            };
+        }
     }
     return {
         type: 'object',
@@ -216,6 +252,9 @@ function buildReadOperation(endpoint) {
             }
             const pageNo = typeof args.pageNo === 'number' ? args.pageNo : 1;
             const pageSize = typeof args.pageSize === 'number' ? args.pageSize : 20;
+            // 服务端过滤条件：count 与 list 必须用**同一份**，否则 total 与当页行数对不上
+            // （总数是不带过滤的、列表是过滤后的，用户会看到"共 155 间"却只回 1 条）。
+            const mainTableFilters = pickMainTableFilters(args, endpoint.mainTableParams);
             let total;
             if (endpoint.countPk && args.withCount !== false) {
                 const countResponse = await env.host.request({
@@ -223,7 +262,7 @@ function buildReadOperation(endpoint) {
                     path: `${EB_BASE}/getFormDataCount/${endpoint.countPk}`,
                     operation: endpoint.operation,
                     query,
-                    body: queryBody(session.userId),
+                    body: queryBody(session.userId, undefined, mainTableFilters),
                     acceptBusiness,
                 });
                 total = extractEbCount(countResponse);
@@ -234,13 +273,61 @@ function buildReadOperation(endpoint) {
                 operation: endpoint.operation,
                 query: { ...query, pageNo, pageSize },
                 // 分页同时进 body.pageInfo：EB 只认 body 里的 pageInfo，仅放 URL query 会被忽略。
-                body: queryBody(session.userId, { pageNo, pageSize }),
+                body: queryBody(session.userId, { pageNo, pageSize }, mainTableFilters),
                 acceptBusiness,
             });
-            const { rows, total: listTotal } = extractEbRows(response);
+            const { rows: rawRows, total: listTotal } = extractEbRows(response);
+            // 服务端过滤不可靠时的兜底：2026-10-30 实测 e-cology 生产环境，
+            // `getFormDataCount/query_meeting_room_count` **完全忽略** mainTable / URL query 的过滤条件
+            // （无过滤 155、room_name=测试 155、room_name=zzz不存在 155，全是 155），
+            // 而 list 又可能只回当页 —— 只靠服务端过滤会得到"total=155 但一条都不匹配"的假结果。
+            // 所以只要调用方传了筛选字段，就在本地按同一条件再筛一遍，保证结果正确。
+            const filterKeys = Object.keys(mainTableFilters);
+            const matchesFilters = (row) => {
+                const main = (row?.mainTable ?? row ?? {});
+                return filterKeys.every((key) => {
+                    const cell = main[key];
+                    if (cell === undefined || cell === null)
+                        return false;
+                    return String(cell).includes(String(mainTableFilters[key]));
+                });
+            };
+            let rows = filterKeys.length === 0 ? rawRows : rawRows.filter(matchesFilters);
+            let fallback;
+            // ⚠️ 服务端是**精确匹配**，模糊词拿不到数据（2026-10-30 实测 e-cology：
+            //   room_name=测试会议室1 → 1 条 ✅；room_name=测试 / 重庆 → 0 条 ❌，
+            //   但全量里明明有「重庆会议室一/二」）。
+            // 传了筛选却一条没命中时，回退：不带过滤翻页拉全量，在客户端按 contains 再筛一遍。
+            // 只在首轮 0 条时触发（精确命中时零额外开销）；`noFallback:true` 可关。
+            if (filterKeys.length > 0 && rows.length === 0 && args.noFallback !== true) {
+                const maxPages = readFallbackMaxPages();
+                const collected = [];
+                let pages = 0;
+                for (let p = 1; p <= maxPages; p += 1) {
+                    const pageResponse = await env.host.request({
+                        method: 'POST',
+                        path,
+                        operation: endpoint.operation,
+                        query: { ...query, pageNo: p, pageSize },
+                        // 不带 mainTableFilters：服务端只会做精确匹配，带上就又变成 0 条了
+                        body: queryBody(session.userId, { pageNo: p, pageSize }),
+                        acceptBusiness,
+                    });
+                    const { rows: pageRows } = extractEbRows(pageResponse);
+                    pages = p;
+                    if (pageRows.length === 0)
+                        break; // 翻到空页 = 到底了
+                    collected.push(...pageRows);
+                    if (p >= maxPages)
+                        break;
+                }
+                fallback = { pages, scanned: collected.length };
+                rows = collected.filter(matchesFilters);
+            }
             // count 接口与实际行数不一致时（本租户 `query_mt_topic_count` 恒返回 0，而 list 有数据），
             // 以"实际取到的行数"为下限，避免出现 total=0 却有数据的自相矛盾结果。
-            const resolvedTotal = total ?? listTotal ?? rows.length;
+            // ⚠️ 有筛选时 count 不可信（见上），一律以本地筛完的行数为准。
+            const resolvedTotal = filterKeys.length > 0 ? rows.length : (total ?? listTotal ?? rawRows.length);
             // 结果后处理（如决议任务进度 / 签到回执出席汇总）：只**增**一个字段，原始 rows 原样返回。
             // 统一注入 `page`（本页 + 总数），避免各实现把"当页行数"误当成总数（2026-09-22 踩到：
             // 签到全量 261 条、pageSize=200 时，summary 里写的 total 只有 200）。
@@ -249,6 +336,8 @@ function buildReadOperation(endpoint) {
                 pageSize,
                 pageCount: rows.length,
                 total: Math.max(resolvedTotal, rows.length),
+                // 模糊回退时告知调用方：结果是客户端筛出来的，扫了多少条
+                ...(fallback ? { fallback } : {}),
             };
             const summarized = endpoint.summarizeRows
                 ? endpoint.summarizeRows(rows, {
@@ -270,11 +359,19 @@ function buildReadOperation(endpoint) {
             // 所以这里只提示翻页/加大 pageSize，不要写成"服务端限制"。
             const effectiveTotal = Math.max(resolvedTotal, rows.length);
             const pageWarnings = [];
+            if (effectiveTotal === 0 && endpoint.emptyHint) {
+                pageWarnings.push(endpoint.emptyHint);
+            }
             if (effectiveTotal > rows.length) {
                 const missing = effectiveTotal - rows.length;
                 pageWarnings.push(`本页返回 ${rows.length} 条，共 ${effectiveTotal} 条：还有 ${missing} 条未取到。`
                     + `需要全量请翻页（pageNo=${pageNo + 1} 起）或加大 pageSize，或收窄筛选条件`);
             }
+            if (fallback) {
+                pageWarnings.push(`服务端只支持「精确匹配」，按 ${filterKeys.join('/')} 过滤后 0 条；`
+                    + `已翻页扫描全量 ${fallback.scanned} 条（${fallback.pages} 页）在客户端按「包含」重新筛选，命中 ${rows.length} 条。`
+                    + `传 noFallback:true 可跳过这次扫描`);
+            }
             return meetingSuccess(endpoint.operation, {
                 total: effectiveTotal,
                 pageNo,
@@ -282,7 +379,7 @@ function buildReadOperation(endpoint) {
                 count: rows.length,
                 ...(progress ? { progress } : {}),
                 rows,
-                filters: query,
+                filters: { ...query, ...mainTableFilters },
             }, {
                 ...(endpoint.notes ? { meta: { notes: endpoint.notes } } : {}),
                 ...(pageWarnings.length > 0 ? { warnings: pageWarnings } : {}),
@@ -426,6 +523,26 @@ export function normalizeEbWrite(endpoint, args, userId) {
         if (hours !== undefined)
             mainTable.mt_hours = hours;
     }
+    // 自定义字段透传（2026-10-28）：租户在表单上新增的字段不在内置白名单内，
+    // 调用方用 extraFields 按**真实字段名**（config.dataKey，或字段 id）传入，原样并入主表。
+    // ⚠️ 这里不做字段名校验 —— 校验了就等于又造一份白名单，而租户加了什么字段只有他的环境知道。
+    // 但必须如实回报"哪些进去了、哪些被内置字段挤掉了"，避免调用方以为写上了。
+    let extraApplied = [];
+    let extraSkipped = [];
+    const extra = args.extraFields;
+    if (extra && typeof extra === 'object' && !Array.isArray(extra)) {
+        for (const [rawKey, value] of Object.entries(extra)) {
+            const key = String(rawKey).trim();
+            if (!key)
+                continue;
+            if (mainTable[key] !== undefined) {
+                extraSkipped.push(key);
+                continue;
+            }
+            mainTable[key] = value;
+            extraApplied.push(key);
+        }
+    }
     const required = endpoint.kind === 'delete'
         ? (endpoint.batchDeleteFields ?? ['id'])
         : endpoint.requiredFields ?? [];
@@ -472,7 +589,14 @@ export function normalizeEbWrite(endpoint, args, userId) {
                 operateType[node] = 'cover';
         }
     }
-    return { mainTable, details, operateType };
+    return {
+        mainTable,
+        details,
+        operateType,
+        ...(extraApplied.length > 0 || extraSkipped.length > 0
+            ? { extraFields: { applied: extraApplied, skipped: extraSkipped } }
+            : {}),
+    };
 }
 function buildWriteInputSchema(endpoint, includeConfirm) {
     const properties = {};
@@ -480,6 +604,15 @@ function buildWriteInputSchema(endpoint, includeConfirm) {
         properties.confirm = { const: true };
         properties.continuation = { type: 'string', minLength: 1 };
     }
+    // 建会/改会：参会人时间冲突时默认阻断，由用户确认后带 conflictAck=true 再提交。
+    if (endpoint.interfacePk === 'create_meeting' || endpoint.interfacePk === 'change_meeting') {
+        properties.conflictAck = {
+            type: 'boolean',
+            description: '参会人时间冲突时仍按原时间建会/改期（默认 false）。'
+                + '冲突时 CLI 会先拒绝并返回冲突明细与当天可选时段，请**用选项方式让用户确认**；'
+                + '用户确认继续后才带 conflictAck=true 重新提交。',
+        };
+    }
     if (endpoint.kind === 'delete') {
         if (endpoint.batchDeleteFields && endpoint.batchDeleteFields.length > 0) {
             // 批量删除：按业务条件删（如 delete_roomusage 的 mt_id），不是主键
@@ -524,6 +657,15 @@ function buildWriteInputSchema(endpoint, includeConfirm) {
                 },
             };
         }
+        // 租户自定义字段透传：表单上后加的字段（如参会客户、联系方式）不在内置清单里，
+        // 只有这个口子能带进去。字段名必须是表单真实 dataKey 或字段 id —— 先用
+        // `meeting.form.fields` 读出来再填，不要凭中文名猜。
+        properties.extraFields = {
+            type: 'object',
+            description: '自定义字段透传，形如 {"字段名": 值}：用于租户在表单上新增、不在本接口内置字段清单里的字段'
+                + '（例如参会客户 crm_members、自建的联系方式字段）。字段名必须是表单真实 dataKey 或字段 id'
+                + '（用 meeting.form.fields 查）；与内置字段同名时以内置字段为准，并在 warnings 里说明',
+        };
         if (endpoint.detailCover) {
             properties.detail1Mode = {
                 type: 'string',
@@ -597,6 +739,18 @@ function buildWriteOperations(endpoint, preflight, afterWrite) {
             // EB 版建会缺少强制冲突检测会重复占用会议室/参会人撞会，故 prepare 阶段由钩子补齐。
             const extras = {};
             const warnings = preflight ? await preflight({ endpoint, args, payload, env, extras }) : [];
+            // 自定义字段如实回报：服务端未配置该字段时会**静默丢弃**（不报错），
+            // 不提示的话调用方会以为写上了。
+            const extraInfo = payload.extraFields;
+            if (extraInfo && extraInfo.applied.length > 0) {
+                warnings.push(`已透传 ${extraInfo.applied.length} 个自定义字段：${extraInfo.applied.join('、')}`
+                    + '——这些不在内置字段清单里，按你给的原样提交；若服务端表单没配这个字段会被静默丢弃，'
+                    + '提交后请回读确认（可用 meeting.form.fields 核对真实字段名）');
+            }
+            if (extraInfo && extraInfo.skipped.length > 0) {
+                warnings.push(`这些自定义字段与内置字段重名，已忽略你的取值、沿用内置字段：${extraInfo.skipped.join('、')}`
+                    + '（要传自定义口径请改用不冲突的字段名）');
+            }
             // 支持明细覆盖的接口（如 update_mt_decision）默认是「更新追加」：真机实测同 sort_number 也会**新增一行**。
             // 调用方最容易在这里理解错，故 prepare 就明确提示，而不是等回读发现多了一行。
             if (endpoint.detailCover && Object.keys(payload.details).length > 0 && payload.operateType.detail1 !== 'cover') {
@@ -648,6 +802,14 @@ function buildWriteOperations(endpoint, preflight, afterWrite) {
                 // 带上两侧快照：`target_changed` 否则无从判断到底哪个字段变了（排查成本极高）。
                 throw meetingValidationError('target_changed', '提交内容与 prepare 时的快照不一致，请重新执行 prepare', { expected: lease.payload, actual: payload });
             }
+            // ⛔ 建会路径闸门在 apply 侧**重新校验**（2026-10-29 真机事故）：
+            // 闸门此前只在 prepare 的 preflight 里，apply 只认 continuation 签名 ⇒ 只要 prepare 那次判定
+            // 侥幸通过（或多份设置里取到了开关为空的那份），10 分钟有效期内就能直连建出会议。
+            // 管控开关可能在 prepare 之后被管理员改过，所以这里不信任快照，重新读一次。
+            if (endpoint.interfacePk === 'create_meeting') {
+                const { fetchEbAppSettings, assertEbCreatePathAllowed } = await import('./conflict.js');
+                assertEbCreatePathAllowed(await fetchEbAppSettings(env, applyName));
+            }
             const pkQuery = writePkQuery(endpoint, payload);
             let response;
             try {

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

@@ -46,8 +46,13 @@ import { meetingEbCreateFlowOperations } from './create-flow.js';
 const ebAutoRoomPreflight = async (context) => {
     const { extras } = context;
     const warnings = [];
-    const enabled = String(process.env.WEAVER_MEETING_AUTO_ROOM ?? '1') !== '0';
     const isCreate = context.endpoint.kind === 'create' && context.endpoint.interfacePk === 'create_meeting';
+    // 会议室推荐拿不到候选时，必须把原因显式暴露给调用方（2026-10-29 真机事故）：
+    // 此前只 push 一条 warning，prepare 照常返回 ok，智能体当没发生 → 会议建成「会议室未指定」，
+    // 用户看到的就是"根本没给我推荐会议室"。
+    const markRoomUnavailable = (reason, meta) => {
+        extras.roomUnavailable = { reason, ...(meta ? { meta } : {}) };
+    };
     // 会议室策略（用户口径）：**不替用户决定** —— 没填会议室就列候选让用户选。
     // - WEAVER_MEETING_AUTO_ROOM=1  显式开启"自动选推荐间"（自动化场景）
     // - WEAVER_MEETING_AUTO_ROOM=0  不推荐也不拦（线上会/无会议室场景）
@@ -98,16 +103,24 @@ const ebAutoRoomPreflight = async (context) => {
                 }
                 else {
                     warnings.push(...result.warnings);
+                    markRoomUnavailable(`没有可用的会议室候选（共 ${result.meta?.roomsTotal ?? 0} 间，可用 ${result.meta?.roomsUsable ?? 0} 间，`
+                        + `该时段被占用 ${result.meta?.roomsBusy ?? 0} 间）`, result.meta);
+                    warnings.push('⚠️ 本次建会**没有会议室**：推荐不出候选（见 roomUnavailable.reason）。'
+                        + '必须用选项方式让用户确认地点 —— 改指定具体会议室（传 address）、改为线上会议，'
+                        + '或明确接受「地点待定」。不要默默建成一场没有地点的会。');
                 }
             }
             catch (error) {
                 if (error?.subtype === 'room_selection_required')
                     throw error;
-                warnings.push(`会议室推荐失败（${String(error?.message ?? error).slice(0, 80)}）：本次不填会议室继续，请与用户确认地点`);
+                const reason = String(error?.message ?? error).slice(0, 200);
+                markRoomUnavailable(`会议室推荐失败：${reason}`);
+                warnings.push(`⚠️ 会议室推荐失败（${reason}）：本次**不填会议室继续**，请与用户确认地点，不要默认「地点待定」。`);
             }
         }
         else {
-            warnings.push('会议开始/结束时间不完整，跳过会议室推荐');
+            markRoomUnavailable('会议开始/结束时间不完整，无法按时段推荐');
+            warnings.push('会议开始/结束时间不完整，跳过会议室推荐（本次不会填会议室，请与用户确认地点）');
         }
     }
     const conflictWarnings = await ebMeetingWritePreflight(context);

package/dist/shortcuts/meeting/operations/eb/room-recommend.js

@@ -1,7 +1,14 @@
 import { meetingSuccess, schemaOf, SCHEMA_DATETIME_MINUTE } from '../types.js';
 import { EB_BASE, ebBusinessSuccess, extractEbRows, queryBody } from './factory.js';
 import { readCache, writeCache, cacheScopeSuffix } from './cache.js';
+// 会议室台账缓存 24h（用户 2026-10-30 明确要求：不要为了新鲜度把 TTL 缩到 15 分钟，太频繁）。
+// 「刚导入/新建的会议室看不到」靠两层兜底解决，而不是靠缩短 TTL：
+//   ① **建会链路强制拉最新**（create.flow.prepare / quick / create.suggest 传 refreshRooms: true）——
+//      这些是"要下单"的场景，宁可多一次请求也必须准；
+//   ② **候选为空且来自缓存 → 自动强制重拉重算**（见下方 candidates.length === 0 分支）。
+// 纯查询（room.recommend）走 24h 缓存保持快；缓存超过 STALE_NOTICE_MS 会在 warnings 提示可用 refresh 刷新。
 const ROOMS_TTL_MS = 24 * 60 * 60 * 1000;
+const STALE_NOTICE_MS = 4 * 60 * 60 * 1000;
 const FREQUENT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const FREQUENT_WINDOW_DAYS = 180;
 const PAGE_SIZE = 100;
@@ -176,6 +183,11 @@ export async function recommendRooms(env, input) {
     const topN = Math.max(1, Math.min(10, input.topN ?? 3));
     const roomData = await loadRooms(env, { refresh: input.refreshRooms === true });
     warnings.push(...roomData.warnings);
+    // 缓存 4 小时以上 → 提示数据可能过时（不是报错，只是让调用方知道"刚加的会议室可能还看不到"）。
+    if (roomData.fromCache && (roomData.ageSeconds ?? 0) * 1000 > STALE_NOTICE_MS) {
+        warnings.push(`会议室台账来自 ${Math.round((roomData.ageSeconds ?? 0) / 3600)} 小时前的缓存（共 ${roomData.rooms.length} 间）。`
+            + '如果最近新建/导入/封存过会议室，请带 `refresh: true` 重新查询，否则看到的是旧清单。');
+    }
     const frequent = await loadFrequentRooms(env, { refresh: input.refreshFrequent === true });
     warnings.push(...frequent.warnings);
     const busy = await fetchBusyRoomIds(env, input.beginDatetime, input.endDatetime);
@@ -195,12 +207,15 @@ export async function recommendRooms(env, input) {
             if (!input.includeBusy)
                 continue;
         }
+        let belowMinCapacity = false;
         if (memberCount !== null) {
-            // allow_maxnum = 0 视为「不限」，超出上限或低于下限都算不满足（下限只在配置了才判）
+            // allow_maxnum = 0 视为「不限」。上限不够 → 真的坐不下，必须排除。
             if (room.maxNum > 0 && room.maxNum < memberCount)
                 continue;
+            // ⚠️ 下限（建议最少人数）不满足**不再直接排除**：小会议（1~2 人）会被所有"最少 2 人"的房间全判死，
+            // 出现「可用 N 间却 0 候选」的死角（2026-10-30 真机）。改为降级候选并标注，让用户自己判断。
             if (room.minNum > 0 && room.minNum > memberCount)
-                continue;
+                belowMinCapacity = true;
         }
         if (requirement.roomAttr && room.roomAttr !== requirement.roomAttr)
             continue;
@@ -228,6 +243,10 @@ export async function recommendRooms(env, input) {
             reasons.push(`容量 ${room.maxNum} 人`);
             score += 5;
         }
+        if (belowMinCapacity) {
+            reasons.push(`该房间建议至少 ${room.minNum} 人使用（本次 ${memberCount} 人，未达建议下限，如可用请自行确认）`);
+            score -= 15;
+        }
         if (requirement.placeKeyword) {
             reasons.push(`地点匹配「${requirement.placeKeyword}」`);
             score += 10;
@@ -265,10 +284,36 @@ export async function recommendRooms(env, input) {
             return leftCap - rightCap;
         return left.name.localeCompare(right.name, 'zh-Hans-CN');
     });
+    // ⛔ 候选为空且数据来自缓存 → 缓存可能已过时（刚导入会议室、房间刚解封、容量刚改），
+    // 静默用旧缓存回答会让用户得出"系统里没有会议室/只有一间"的错误结论（2026-10-30 真机事故）。
+    // 这里自动强制重拉一次再算；只有重拉后仍为空才如实报告。不递归：refreshRooms=true 时直接跳过。
+    if (candidates.length === 0 && roomData.fromCache && input.refreshRooms !== true) {
+        const retried = await recommendRooms(env, { ...input, refreshRooms: true, refreshFrequent: true });
+        return {
+            ...retried,
+            meta: { ...retried.meta, cacheRetried: true },
+            warnings: [
+                `缓存里的会议室凑不出候选（缓存 ${Math.round((roomData.ageSeconds ?? 0) / 60)} 分钟前，`
+                    + `${roomData.rooms.length} 间）→ 已强制重新拉取台账后重算`,
+                ...retried.warnings,
+            ],
+        };
+    }
     if (candidates.length === 0) {
-        warnings.push(`没有满足条件的空闲会议室（共 ${roomData.rooms.length} 间，可用 ${usable.length} 间，`
-            + `该时段被占用 ${busyCount} 间${memberCount ? `，人数 ${memberCount}` : ''}）`
-            + '——请放宽人数/地点/设备要求，或改为线上会议。');
+        if (roomData.rooms.length === 0) {
+            // 2026-10-29 真机事故：0 间时只说了"放宽条件"，agent 转头去调标准版 meeting.room.list，
+            // 把标准版那套 74 间会议室外加给了用户。空结果必须把"不是环境问题、更不许换标准版"说清楚。
+            warnings.push('EB 会议室表（`uf_mt_room_base`）查不到任何记录（roomsTotal=0）。可能是：① 该环境确实还没建过会议室；'
+                + '② 会议应用的「会议室列表」接口/视图未配置（`query_meeting_room_list` 读不到数据，但表里可能有）。'
+                + '**绝对不要改用 `meeting.room.list`** —— 那是标准版会议应用的会议室，与 EB 是两套完全不通的数据，'
+                + '拿给用户等于凭空捏造房间。请如实告知用户"EB 会议室查不到"，并请管理员检查会议室配置，'
+                + '或让用户直接提供会议室名称/改用线上会议。');
+        }
+        else {
+            warnings.push(`没有满足条件的空闲会议室（共 ${roomData.rooms.length} 间，可用 ${usable.length} 间，`
+                + `该时段被占用 ${busyCount} 间${memberCount ? `，人数 ${memberCount}` : ''}）`
+                + '——请放宽人数/地点/设备要求，或改为线上会议。');
+        }
     }
     return {
         best: candidates[0] ?? null,

package/dist/shortcuts/meeting/operations/eb-fallback.js

@@ -0,0 +1,163 @@
+import { MeetingCliError } from '../errors.js';
+import { degradeMeetingEnvToStandard } from './env.js';
+// ---------------------------------------------------------------------------
+// EB 优先 + 失败降级到标准版
+//
+// 会议有两种实现（EB 版 eBuilder 表单接口 / 标准版 Java REST），此前靠调用方先跑
+// `meeting.env.detect` 决定走哪一套 —— 每次调用前都要两路冒烟，且一次偶发抖动就会把
+// 整个环境误判成另一套。现在改为**惰性降级**：默认按 EB 执行，EB 真走不通时才实探
+// 标准版，成功后把 `standard` 写进 env 缓存（`meeting/env-mode.json`），
+// 后续同一 baseUrl 直接走标准版。
+// ---------------------------------------------------------------------------
+/**
+ * EB operation → 标准版对等 operation。
+ * - 字符串：可直接改用的标准版 operation；
+ * - `null`：标准版**明确没有**对应能力（不要引导用户去试）。
+ */
+const EB_TO_STANDARD = {
+    'meeting.eb.meeting.list': 'meeting.list',
+    'meeting.eb.meeting.detail': 'meeting.detail.field',
+    'meeting.eb.meeting.create.prepare': 'meeting.create.prepare',
+    'meeting.eb.meeting.create.apply': 'meeting.create.apply',
+    'meeting.eb.meeting.change.prepare': 'meeting.change.prepare',
+    'meeting.eb.meeting.change.apply': 'meeting.change.apply',
+    'meeting.eb.meeting.delete.prepare': 'meeting.delete.prepare',
+    'meeting.eb.meeting.delete.apply': 'meeting.delete.apply',
+    'meeting.eb.room.list': 'meeting.room.list',
+    'meeting.eb.room.detail': null,
+    'meeting.eb.room.create.prepare': null,
+    'meeting.eb.room.create.apply': null,
+    'meeting.eb.room.update.prepare': null,
+    'meeting.eb.room.update.apply': null,
+    'meeting.eb.room.delete.prepare': null,
+    'meeting.eb.room.delete.apply': null,
+    'meeting.eb.roomUsage.list': 'meeting.room.usage',
+    'meeting.eb.sign.list': 'meeting.sign.list',
+    'meeting.eb.sign.mark.prepare': 'meeting.sign.mark.prepare',
+    'meeting.eb.sign.mark.apply': 'meeting.sign.mark.apply',
+    'meeting.eb.receipt.list': 'meeting.receipt.list',
+    'meeting.eb.receipt.update.prepare': 'meeting.receipt.update.prepare',
+    'meeting.eb.receipt.update.apply': 'meeting.receipt.update.apply',
+    'meeting.eb.type.list': 'meeting.type.list',
+    'meeting.eb.conflict.room': 'meeting.conflict.room',
+    'meeting.eb.conflict.member': 'meeting.conflict.member',
+    'meeting.eb.conflict.availability': null,
+    'meeting.eb.baseSet.get': 'meeting.calendar.base',
+    'meeting.eb.minute.create.prepare': null,
+    'meeting.eb.minute.create.apply': null,
+    'meeting.eb.topic.list': null,
+    'meeting.eb.decision.create.prepare': null,
+    'meeting.eb.decision.create.apply': null,
+    'meeting.eb.decisionTask.list': null,
+    'meeting.eb.schedule.free': null,
+    'meeting.eb.room.recommend': null,
+    'meeting.eb.meeting.create.flow.prepare': null,
+    'meeting.eb.meeting.create.flow.apply': null,
+    'meeting.eb.meeting.create.flow.quick': null,
+};
+/**
+ * **不该**触发降级的错误：这些是登录、权限、参数、业务策略或确认链问题，
+ * 换成标准版接口也一定重蹈覆辙，降级只会掩盖真正的原因。
+ */
+const NO_FALLBACK_TYPES = new Set(['validation', 'confirmation', 'continuation']);
+const NO_FALLBACK_SUBTYPES = new Set([
+    'session_expired',
+    'permission_denied',
+    'not_found',
+    'missing_required_field',
+    'datetime_invalid',
+    'id_invalid',
+    'conflict_rejected',
+    'flow_not_launchable',
+    'target_changed',
+    'env_unavailable',
+    'env_fallback',
+]);
+function describe(error) {
+    if (error instanceof MeetingCliError) {
+        return `${error.type}/${error.subtype}: ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `${error.type ?? 'api'}/${error.subtype ?? 'error'}: ${error.message}`;
+    }
+    return String(error);
+}
+/**
+ * 是不是「EB 接口这座城根本没有」的结构性信号（404/405/501 或服务端明说接口不存在）。
+ * 只有这类错误才**持久**降级并写缓存；5xx / 网络抖动这类偶发故障只降级本次，不动缓存，
+ * 否则一次抖动就会把整个环境永久标成标准版（2026-10-29 定）。
+ */
+function isEbStructurallyAbsent(error) {
+    const status = error?.details?.status ?? error?.code;
+    if (status === 404 || status === 405 || status === 501)
+        return true;
+    if (error?.subtype === 'http_error' && typeof status === 'number' && status >= 400 && status < 500)
+        return true;
+    const message = String(error?.message ?? '');
+    return /接口不存在|不存在该接口|NoHandler|No mapping|Not Found|路由不存在|does not exist/i.test(message);
+}
+function peerHint(operation) {
+    if (!(operation in EB_TO_STANDARD))
+        return {};
+    const peer = EB_TO_STANDARD[operation];
+    return peer == null ? { unavailable: true } : { peer };
+}
+/**
+ * EB operation 失败后的降级处理。
+ *
+ * @returns 降级成功时返回一个携带切换指引的 `env_fallback` 错误；**标准版也不通或本就不该降级时
+ *          返回 `null`**（调用方应保持抛出原始错误，原始错误的诊断价值更高）。
+ */
+export async function tryDegradeEbFailure(operation, error, host, ctx) {
+    if (!operation.startsWith('meeting.eb.'))
+        return null;
+    // 手动开关：确认某环境就是 EB 版时，关掉自动降级避免反复实探。
+    if (process.env.WEAVER_MEETING_ENV_AUTOFALLBACK === '0')
+        return null;
+    // 固化自用（2026-10-30）：`WEAVER_MEETING_LOCK_MODE=eb` 明确锁死 EB —— 生产环境一次接口抖动
+    // 就把模式改成 standard，后面整条链路走标准版（会议室台账、字段口径都不一样），比直接报错更难排查。
+    if (String(process.env.WEAVER_MEETING_LOCK_MODE ?? '').trim().toLowerCase() === 'eb')
+        return null;
+    const type = String(error?.type ?? '');
+    const subtype = String(error?.subtype ?? '');
+    if (NO_FALLBACK_TYPES.has(type) || NO_FALLBACK_SUBTYPES.has(subtype))
+        return null;
+    let ebErrorDetail = describe(error);
+    const persist = isEbStructurallyAbsent(error);
+    try {
+        const degraded = await degradeMeetingEnvToStandard(host, ctx, error, { persist });
+        ebErrorDetail = degraded.ebError || ebErrorDetail;
+    }
+    catch {
+        // 标准版也不通 → 保留原始错误（比 env_unavailable 更有信息量）。
+        return null;
+    }
+    const hint = peerHint(operation);
+    const action = hint.peer
+        ? `请改用标准版 operation **\`${hint.peer}\`** 重试（参数口径不同，先跑 \`meeting schema\` 看该 operation 的 inputSchema）。`
+        : hint.unavailable
+            ? '标准版**没有**该能力的对等实现，请如实告知用户本环境无法完成这项操作，不要用其它接口拼凑。'
+            : '标准版清单见 `meeting schema`，挑语义最接近的 operation（先确认 inputSchema 再调用）。';
+    const modeNote = persist
+        ? '已实探标准版接口可用，**环境模式已更新为 `standard` 并写入缓存**，后续同一环境直接走标准版。'
+        : '标准版接口本次探测可用，但这是 EB 侧的偶发故障（HTTP 5xx / 网络类），**没有改动模式缓存**，下次仍会先按 EB 版尝试。';
+    const message = [
+        `EB 版会议接口在当前环境不可用（${ebErrorDetail}）。`,
+        modeNote,
+        action,
+        '若确认本环境其实是 EB 版（例如刚安装完会议 EB 应用），跑 `meeting.env.detect`（`refresh:true`）重新判定即可。',
+    ].join(' ');
+    return new MeetingCliError('api', 'env_fallback', message, {
+        code: 'env_fallback',
+        details: {
+            ebOperation: operation,
+            ebError: ebErrorDetail,
+            standardOperation: hint.peer ?? null,
+            standardUnavailable: hint.unavailable === true,
+            // persist=true 时降级已落盘，调用方不必重复 detect。
+            envModeUpdated: persist ? 'standard' : null,
+        },
+        retryable: false,
+        exitCode: 1,
+    });
+}