weaver-work-cli 0.1.32 → 0.1.33

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

@@ -270,6 +270,9 @@ 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} 条未取到。`
@@ -426,6 +429,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 +495,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 +510,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 +563,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 +645,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 +708,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

@@ -266,9 +266,20 @@ export async function recommendRooms(env, input) {
         return left.name.localeCompare(right.name, 'zh-Hans-CN');
     });
     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,159 @@
+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;
+    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,
+    });
+}

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

@@ -29,7 +29,7 @@ function cacheFile(ctx) {
 function emptyCache() {
     return { schemaVersion: 1, environments: {} };
 }
-async function readCache(ctx) {
+export async function readCache(ctx) {
     const file = cacheFile(ctx);
     if (!existsSync(file))
         return emptyCache();
@@ -58,79 +58,126 @@ async function writeCache(ctx, baseUrl, mode, smokePath) {
     }
 }
 /**
- * 解析当前环境的会议模式（EB / 标准版），供 `meeting.env.detect` 与 `meeting.link`
- * 共用同一套缓存与冒烟逻辑（避免两处判定不一致导致链接模式选错）。
+ * 没有探测结论时的默认模式：**一律先按 EB 版走**。
+ *
+ * ⛔ 此前每次业务调用前都会先跑 EB + 标准版两路冒烟才算得出模式，既多两次请求，
+ * 又把「BB 月接口偶发抖动」直接放大成「整环境被判成标准版」。现改为惰性判定：
+ * 先假设 EB，等 EB 真走不通了再由 `degradeMeetingEnvToStandard` 实探降级。
  */
-export async function resolveMeetingEnvMode(host, ctx, options = {}) {
+const DEFAULT_MEETING_MODE = 'eb';
+function describeEnvError(error) {
+    if (error instanceof Error) {
+        return `${error.type ?? 'api'}/${error.subtype ?? 'error'}: ${error.message}`;
+    }
+    return String(error);
+}
+/**
+ * 双路冒烟并把结论写进缓存：EB 优先，失败回退标准版。
+ * **只在 `refresh=true` 或 EB 实际失败需要降级时调用** —— 业务调用前不再冒烟。
+ *
+ * @param knownEbError 已经发生的 EB 错误：直接跳过 EB 冒烟，避免为同一次失败多打一个请求。
+ */
+async function probeAndPersist(host, ctx, knownEbError, options = {}) {
+    const persist = options.persist !== false;
     const session = await host.getSession();
-    // ① 默认先读缓存（按 baseUrl 固化）；refresh=true 才强制重新冒烟。
-    if (options.refresh !== true) {
-        const cache = await readCache(ctx);
-        const cached = cache.environments[session.baseUrl];
-        if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
-            return {
-                mode: cached.mode,
-                smokePath: cached.smokePath,
-                fromCache: true,
-                detectedAt: cached.detectedAt,
-            };
+    // ① EB 版冒烟。接口 404/业务失败均视为「EB 未配置」。
+    let ebError = knownEbError;
+    if (ebError === undefined) {
+        try {
+            await host.request({
+                method: 'POST',
+                path: EB_SMOKE_PATH,
+                operation: 'meeting.env.detect',
+                // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
+                // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
+                // 标准版（2026-09-20 真机复现）。
+                body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
+                // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
+                // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
+                acceptBusiness: ebBusinessSuccess,
+            });
+            const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
+            return { mode: 'eb', smokePath: EB_SMOKE_PATH, warning };
+        }
+        catch (error) {
+            ebError = error;
         }
     }
-    // ② 第 1 步：EB 版冒烟（EB 优先）。接口 404/业务失败均视为「EB 未配置」。
-    let ebError;
-    try {
-        await host.request({
-            method: 'POST',
-            path: EB_SMOKE_PATH,
-            operation: 'meeting.env.detect',
-            // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
-            // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
-            // 标准版（2026-09-20 真机复现）。
-            body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
-            // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
-            // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
-            acceptBusiness: ebBusinessSuccess,
-        });
-        const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
-        return { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false, warning };
-    }
-    catch (error) {
-        ebError = error;
-    }
-    // ③ 第 2 步：标准版冒烟（仅当 EB 冒烟未通过）。
+    // ② 标准版冒烟（仅当 EB 冒烟未通过 / 已知 EB 失败）。
     try {
         await host.request({
             method: 'GET',
             path: STD_CALENDAR_PATH,
             operation: 'meeting.env.detect',
         });
-        const ebDetail = ebError instanceof Error
-            ? `${ebError.type ?? 'api'}/${ebError.subtype ?? 'error'}: ${ebError.message}`
-            : String(ebError);
-        const warning = await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH);
+        const warning = persist ? await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH) : undefined;
         return {
             mode: 'standard',
             smokePath: STD_CALENDAR_PATH,
-            fromCache: false,
             ebSmokeFailed: true,
-            ebSmokeError: ebDetail,
+            ebSmokeError: describeEnvError(ebError),
             warning,
         };
     }
     catch (stdError) {
         // 两步都不通 → 不写缓存，提示接口未配置完整。
         throw meetingValidationError('env_unavailable', '当前环境 EB 版与标准版会议接口冒烟均未通过，请确认会议应用已安装且接口已配置完整', {
-            eb: ebError instanceof Error ? ebError.message : String(ebError),
-            standard: stdError instanceof Error ? stdError.message : String(stdError),
+            eb: describeEnvError(ebError),
+            standard: describeEnvError(stdError),
         });
     }
 }
+/**
+ * 解析当前环境的会议模式（EB / 标准版），供 `meeting.env.detect` 与 `meeting.link`
+ * 共用同一套缓存与冒烟逻辑（避免两处判定不一致导致链接模式选错）。
+ *
+ * **默认 EB**：没有探测结论时直接返回 `mode='eb'` + `assumed=true`，不冒烟、不写缓存；
+ * EB 真走不通由调用方触发 `degradeMeetingEnvToStandard` 实探降级。
+ */
+export async function resolveMeetingEnvMode(host, ctx, options = {}) {
+    const session = await host.getSession();
+    // ① refresh=true 才实探（EB 优先，失败回退标准版，结论写进缓存）。
+    if (options.refresh === true) {
+        return { ...(await probeAndPersist(host, ctx)), fromCache: false };
+    }
+    // ② 命中缓存直接用（按 baseUrl 固化）。
+    const cache = await readCache(ctx);
+    const cached = cache.environments[session.baseUrl];
+    if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
+        return {
+            mode: cached.mode,
+            smokePath: cached.smokePath,
+            fromCache: true,
+            detectedAt: cached.detectedAt,
+        };
+    }
+    // ③ 无结论 → 默认按 EB 走。业务调用前不再做双路冒烟（省两请求，也避免抖动误判）。
+    return { mode: DEFAULT_MEETING_MODE, smokePath: EB_SMOKE_PATH, fromCache: false, assumed: true };
+}
+/**
+ * EB 版走不通时的降级入口：实探标准版，通过后把 `standard` 固化进 env 缓存
+ * （后续同一 baseUrl 直接走标准版，不再重复试 EB）。
+ *
+ * @param options.persist false = 只降级本次、**不写缓存**。用于偶发的服务端错误
+ *   （5xx / 网络抖动），避免一次抖动就把整个环境永久标成标准版。
+ *
+ * 标准版也不通则抛 `env_unavailable`。
+ */
+export async function degradeMeetingEnvToStandard(host, ctx, ebError, options = {}) {
+    const probed = await probeAndPersist(host, ctx, ebError, options);
+    return {
+        mode: 'standard',
+        smokePath: probed.smokePath,
+        ebError: probed.ebSmokeError ?? describeEnvError(ebError),
+        ...(probed.warning ? { warning: probed.warning } : {}),
+    };
+}
 const meetingEnvDetect = {
     name: 'meeting.env.detect',
     resource: 'env',
     method: 'detect',
     action: 'meeting.env.detect',
-    summary: '探测当前环境会议模式：默认按 baseUrl 读缓存；未命中或 refresh=true 时 EB 版冒烟优先、失败回退标准版，成功后固化缓存',
+    summary: '探测当前环境会议模式：**无探测结论时直接按 EB 版返回**（`assumed=true`，不冒烟、不写缓存）；EB 走不通时由 EB 调用链自动实探标准版并把 `standard` 固化进缓存；`refresh=true` 强制重新冒烟',
     capability: 'env',
     risk: 'read',
     inputSchema: {

package/dist/shortcuts/meeting/operations/form-fields.js

@@ -0,0 +1,110 @@
+/**
+ * 会议表单**真实字段清单**（只读）。
+ *
+ * 为什么需要：写链路（`create_meeting` / `change_meeting` / 建会流程表单）是按字段名取值与过滤的，
+ * 而租户常常在表单上**自己加字段**（参会客户、联系方式、项目编号……）。这些字段：
+ *   - 不在 CLI 内置白名单里 ⇒ 传不进去（以前只能通过改代码放开）；
+ *   - 也不在接口文档的字段表里 ⇒ 智能体只能瞎猜名字，猜错就被服务端静默丢弃。
+ *
+ * 本 operation 直接读 eBuilder 表单字段定义，把「中文名 / 字段 id / dataKey（写接口真正认的名字）/
+ * 组件类型 / 是否多选」列出来，让调用方**先查再写**：
+ *   查 → `meeting.form.fields { type: 'meeting', keyword: '客户' }`
+ *   写 → 建会/改会传 `extraFields: { "<dataKey>": 值 }`，流程建会传 `extraFields: { "<表单字段名>": 值 }`
+ *
+ * ⚠️ 只读，不写任何东西。
+ */
+import { meetingSuccess } from './types.js';
+import { MEETING_EB_TAGS, resolveMeetingEbObjs } from './eb/link.js';
+function textOf(value) {
+    return value === undefined || value === null ? '' : String(value);
+}
+const TYPES = Object.keys(MEETING_EB_TAGS);
+const meetingFormFields = {
+    name: 'meeting.form.fields',
+    resource: 'eb',
+    method: 'meeting.form.fields',
+    action: 'meeting.form.fields',
+    summary: '读取会议表单的真实字段清单（中文名 / dataKey / 字段 id / 组件类型 / 是否多选），供 extraFields 按真实字段名写入租户自定义字段',
+    capability: 'eb.meta',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            type: {
+                type: 'string',
+                enum: TYPES,
+                description: '要查哪张表：meeting=会议、topic=议题、minutes=纪要、room=会议室、sign=签到、receipt=回执…（默认 meeting）',
+            },
+            keyword: { type: 'string', description: '只返回中文名/dataKey 包含该关键词的字段（如「客户」「联系」）' },
+            refresh: { type: 'boolean', description: '默认读缓存；传 true 强制重新解析表 id 与字段定义' },
+        },
+    },
+    handler: async (args, env) => {
+        const type = (TYPES.includes(args.type) ? args.type : 'meeting');
+        const tag = MEETING_EB_TAGS[type];
+        const resolved = await resolveMeetingEbObjs(env.host, env.ctx, {
+            tags: [tag],
+            ...(args.refresh === true ? { refresh: true } : {}),
+        });
+        const obj = resolved.objs[tag];
+        if (!obj?.objId) {
+            return meetingSuccess('meeting.form.fields', {
+                type,
+                tag,
+                objId: '',
+                fields: [],
+                hint: '没解析到该表的 objId（可能当前环境没有这张表，或账号无权限）',
+            }, { warnings: resolved.warnings });
+        }
+        const { createEbuilderFormHost } = await import('../../ebuilder-form/host.js');
+        const { createEbuilderFormContinuationSigner } = await import('../../ebuilder-form/continuation.js');
+        const { executeEbuilderFormOperation } = await import('../../ebuilder-form/operations.js');
+        const formEnv = {
+            ctx: env.ctx,
+            host: createEbuilderFormHost(env.ctx),
+            continuation: createEbuilderFormContinuationSigner(env.ctx),
+        };
+        const raw = await executeEbuilderFormOperation('ebuilder-form.fields.get', { objId: obj.objId }, formEnv);
+        const nodes = Array.isArray(raw?.data?.result?.data) ? raw.data.result.data : [];
+        const rows = [];
+        const detailTables = [];
+        for (const node of nodes) {
+            const fields = Array.isArray(node?.fields) ? node.fields : [];
+            // 明细表节点：没有 fields，只有名字（如「明细子表1」），单独列出来告诉调用方
+            if (fields.length === 0 && textOf(node?.name)) {
+                detailTables.push(textOf(node.name));
+                continue;
+            }
+            for (const field of fields) {
+                const config = field?.config ?? {};
+                const dataKey = textOf(config.dataKey || config.columnName || field.physicalField);
+                rows.push({
+                    dataKey,
+                    fieldId: textOf(field.name || field.id),
+                    label: textOf(field.text || config.title),
+                    compType: textOf(field.compType || config.componentKey),
+                    type: textOf(field.type || config.type),
+                    multiSelect: String(field.multiSelect ?? 'false') === 'true',
+                });
+            }
+        }
+        const keyword = textOf(args.keyword).trim();
+        const matched = keyword
+            ? rows.filter((row) => row.label.includes(keyword) || row.dataKey.includes(keyword) || row.fieldId.includes(keyword))
+            : rows;
+        return meetingSuccess('meeting.form.fields', {
+            type,
+            tag,
+            objId: obj.objId,
+            tableName: obj.tableName,
+            total: matched.length,
+            fields: matched,
+            detailTables,
+            hint: keyword && matched.length === 0
+                ? `没有匹配「${keyword}」的字段 —— 这张表里确实没有该字段，不要硬填（硬填会被服务端静默丢弃）`
+                : '写会议字段用 dataKey（extraFields）；写建会流程表单用 label（中文名）',
+        }, { warnings: resolved.warnings });
+    },
+};
+export const meetingFormFieldOperations = [meetingFormFields];

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

@@ -19,6 +19,7 @@ import { meetingPipelineOperations } from './pipeline.js';
 import { meetingInvitationOperations } from './invitation.js';
 import { meetingQrOperations } from './qrcode.js';
 import { meetingSummaryOperations } from './summary.js';
+import { meetingFormFieldOperations } from './form-fields.js';
 import { meetingEbOperations } from './eb/index.js';
 function buildRegistry() {
     const registry = new Map();
@@ -43,6 +44,7 @@ function buildRegistry() {
         ...meetingInvitationOperations,
         ...meetingQrOperations,
         ...meetingSummaryOperations,
+        ...meetingFormFieldOperations,
         ...meetingEbOperations,
     ];
     for (const definition of definitions) {