weaver-work-cli 0.1.32 → 0.1.36

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,132 @@ 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();
+    // ⓪ 固化锁定（2026-10-30）：`WEAVER_MEETING_LOCK_MODE=eb` 时恒返回 EB，不读缓存、不冒烟；
+    // 只有 `refresh=true` 才允许实探（用户主动要求重新判定时）。
+    if (options.refresh !== true
+        && String(process.env.WEAVER_MEETING_LOCK_MODE ?? '').trim().toLowerCase() === 'eb') {
+        return { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false, assumed: true, locked: true };
+    }
+    // ① 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/invitation.js

@@ -13,6 +13,7 @@
  * - 数据源必须是 `meeting.eb.meeting.list` 单查（47 字段）；
  *   `meeting.eb.meeting.detail` 在该环境只回 `{id}`，不可用。
  */
+import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -25,8 +26,23 @@ function templatePath() {
     const override = process.env.WEAVER_MEETING_INVITATION_TEMPLATE;
     if (override)
         return resolve(override);
-    // 本文件编译后位于 <pkg>/dist/shortcuts/meeting/operations/，向上四级即包根
+    // ⛔ 不能写死「向上四级」：同一个源文件在两种产物里的位置不一样 ——
+    //   · tsc 直出：<pkg>/dist/shortcuts/meeting/operations/  → 向上四级是包根
+    //   · bundle 打包：<pkg>/dist/chunks/chunk-xxxx.js         → 向上两级才是包根
+    // 2026-10-30 真机踩过：小e 跑的是 bundle 版，写死四级会算出 <pkg>/../templates/… 而报「模板缺失」。
+    // 所以直接逐级向上找，找到第一个存在的就是它。
     const here = dirname(fileURLToPath(import.meta.url));
+    let dir = here;
+    for (let depth = 0; depth < 6; depth += 1) {
+        const candidate = join(dir, 'templates', 'meeting', 'invitation.docx');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // 都没找到：仍按传统层级拼一个路径返回，让报错信息能指向具体位置
     return resolve(here, '../../../../templates/meeting/invitation.docx');
 }
 const WEEKDAYS = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
@@ -344,7 +360,17 @@ const meetingInvitationRender = {
         type: 'object',
         additionalProperties: false,
         properties: {
-            mtId: { ...SCHEMA_ID, description: '会议 id（EB 版 mt_detail 主键）' },
+            mtId: { ...SCHEMA_ID, description: '会议 id（EB 版 mt_detail 主键）。**与下面的字段二选一**：有 mtId 走真实会议数据；没有则用传入字段直接生成（流程建会审批中也能出邀请函）' },
+            mt_name: { type: 'string', description: '会议名称（无 mtId 时必填）' },
+            begin_datetime: { type: 'string', description: '开始时间 `yyyy-MM-dd HH:mm`（无 mtId 时必填）' },
+            end_datetime: { type: 'string', description: '结束时间 `yyyy-MM-dd HH:mm`（无 mtId 时建议填，缺了结束时间会是【待补充】）' },
+            address: { type: 'string', description: '会议地点/会议室**名称**（无 mtId 时用；这里要传名称，不是 id）' },
+            hrm_members: { type: 'string', description: '参会人姓名（逗号/顿号分隔，无 mtId 时用）' },
+            mt_desc: { type: 'string', description: '会议内容/议题概要' },
+            org_members: { type: 'string', description: '落款单位（不传则尝试用发起人部门 / 留【待补充】）' },
+            caller: { type: 'string', description: '召集人' },
+            contacter: { type: 'string', description: '联系人' },
+            total_member: { type: 'string', description: '参会人数' },
             extra: {
                 type: 'object',
                 additionalProperties: { type: 'string' },
@@ -355,13 +381,10 @@ const meetingInvitationRender = {
                 description: '输出文件完整路径（可选）。缺省写到 ~/.weaver-work-cli/meeting/invitations/邀请函-{会议名}-{日期}.docx',
             },
         },
-        required: ['mtId'],
+        required: [],
     },
     handler: async (args, env) => {
         const mtId = String(args.mtId ?? '').trim();
-        if (!mtId) {
-            throw meetingValidationError('mt_id_required', '必须提供会议 id（mtId）');
-        }
         const extra = {};
         if (args.extra && typeof args.extra === 'object') {
             for (const [key, value] of Object.entries(args.extra)) {
@@ -369,20 +392,51 @@ const meetingInvitationRender = {
                     extra[key] = String(value);
             }
         }
-        // 复用已实现的 EB 列表操作（内部先 count 再 list，筛选走 URL query）
-        const { getMeetingOperation } = await import('./registry.js');
-        const listOperation = getMeetingOperation('meeting.eb.meeting.list');
         let row;
-        try {
-            const listed = await listOperation.handler({ mt_id: mtId, pageNo: 1, pageSize: 1 }, env);
-            const rows = (listed.data?.rows ?? []);
-            row = rows[0]?.mainTable ?? rows[0];
-        }
-        catch (error) {
-            throw meetingValidationError('invitation_source_unavailable', `读取会议数据失败（邀请函当前依赖 EB 版会议列表）：${error instanceof Error ? error.message : String(error)}`, { mtId });
+        /** meeting=按真实会议数据；payload=按调用方传入的申请单字段（会议可能还没生成）。 */
+        let dataSource = 'meeting';
+        if (!mtId) {
+            // ⛔ 邀请函本质是「预置函」：项目人员下载后自己改、自己发（2026-10-30 用户明确要求）。
+            // 所以不该卡在"会议必须已生成"——流程还在审批时，用申请单已知信息先生成一份，
+            // 取不到的字段渲染成【待补充】，让人工补。这也保证流程建会提交后立刻能拿到邀请函。
+            const mtName = String(args.mt_name ?? '').trim();
+            const beginText = String(args.begin_datetime ?? '').trim();
+            if (!mtName || !beginText) {
+                throw meetingValidationError('invitation_source_required', '要么传 mtId（按真实会议生成），要么传 mt_name + begin_datetime（按申请单信息预填生成）');
+            }
+            // 无 mtId 时落款单位取当前登录用户的部门（比让用户手填更省事），取不到再留【待补充】
+            const session = await env.host.getSession().catch(() => null);
+            const sessionUserId = String(session?.userId ?? '');
+            row = {
+                mt_name: mtName,
+                begin_datetime: beginText,
+                end_datetime: String(args.end_datetime ?? '').trim(),
+                address: String(args.address ?? '').trim(),
+                hrm_members: String(args.hrm_members ?? '').trim(),
+                mt_desc: String(args.mt_desc ?? '').trim(),
+                org_members: String(args.org_members ?? '').trim(),
+                caller: String(args.caller ?? '').trim(),
+                contacter: String(args.contacter ?? '').trim(),
+                total_member: String(args.total_member ?? '').trim(),
+                creator: sessionUserId,
+            };
+            dataSource = 'payload';
         }
-        if (!row) {
-            throw meetingValidationError('not_found', `未找到会议 id=${mtId}，或当前账号无权限查看`, { mtId });
+        else {
+            // 复用已实现的 EB 列表操作（内部先 count 再 list，筛选走 URL query）
+            const { getMeetingOperation } = await import('./registry.js');
+            const listOperation = getMeetingOperation('meeting.eb.meeting.list');
+            try {
+                const listed = await listOperation.handler({ mt_id: mtId, pageNo: 1, pageSize: 1 }, env);
+                const rows = (listed.data?.rows ?? []);
+                row = rows[0]?.mainTable ?? rows[0];
+            }
+            catch (error) {
+                throw meetingValidationError('invitation_source_unavailable', `读取会议数据失败（邀请函当前依赖 EB 版会议列表）：${error instanceof Error ? error.message : String(error)}`, { mtId });
+            }
+            if (!row) {
+                throw meetingValidationError('not_found', `未找到会议 id=${mtId}，或当前账号无权限查看`, { mtId });
+            }
         }
         // 落款单位回落：会议 org_members 为空时，用「发起人（creator 人员 id）的所属组织」
         const creatorId = String(row.creator ?? '').trim();
@@ -390,7 +444,7 @@ const meetingInvitationRender = {
         const issuerOrg = needsIssuerOrg ? await resolveIssuerOrganization(env, creatorId) : null;
         const { resolver, orgSource } = buildResolver(row, extra, issuerOrg);
         // 议程：议题表 → extra.agenda → 保留模板里的示例行（用户口径：没有就这样）
-        let agendaRows = await loadAgendaFromTopics(env, mtId);
+        let agendaRows = dataSource === 'meeting' && mtId ? await loadAgendaFromTopics(env, mtId) : [];
         let agendaSource = agendaRows.length > 0 ? 'meeting.topic' : 'template';
         if (agendaRows.length === 0) {
             const fromExtra = parseAgendaFromExtra(extra.agenda);
@@ -418,6 +472,9 @@ const meetingInvitationRender = {
         await mkdir(dirname(target), { recursive: true });
         await writeFile(target, rendered.buffer);
         const warnings = [];
+        if (dataSource === 'payload') {
+            warnings.push('本邀请函按**申请单已知信息**预生成（会议可能还在审批中、尚未生成），属于**预置函**：请下载后人工核对/修改再自行发送。会议正式生成后可用 mtId 重新生成一版拿到完整字段。');
+        }
         if (rendered.pending.length > 0) {
             warnings.push(`以下字段取不到值，已渲染成黄色高亮【待补充】，请人工补充：${rendered.pending.join('、')}`);
         }
@@ -438,8 +495,10 @@ const meetingInvitationRender = {
             filePath: target,
             fileName,
             bytes: rendered.buffer.length,
-            meetingId: mtId,
+            meetingId: mtId || null,
             meetingName: String(row.mt_name ?? ''),
+            // meeting=按真实会议数据；payload=按申请单字段预生成（会议可能还没生成，属预置函）
+            dataSource,
             filledFields: rendered.filled,
             pendingFields: rendered.pending,
             // 落款单位的实际来源，便于调用方判断是否需要人工改写

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) {

package/dist/shortcuts/meeting/operations/standard-guard.js

@@ -0,0 +1,71 @@
+import { MeetingCliError } from '../errors.js';
+import { readCache } from './env.js';
+/**
+ * 标准版会议 operation → 对应的 EB operation。
+ *
+ * ⛔ 存在的理由（2026-10-29 真机事故）：e-cology 这类租户**同时装了标准会议应用和 EB 会议应用**，
+ * 两套数据完全不通（标准版 `meeting.room.list` 返回 74 间「317/342/442会议室」，
+ * EB 的 `uf_mt_room_base` 只有 1 间「测试会议室1」）。agent 在 EB 环境误调标准版接口时，
+ * 接口**不会报错、照常返回数据**，于是把根本不存在的会议室/会议摆到用户面前，用户还以为数据错了。
+ *
+ * 所以这里做一道闸：**环境已确认是 EB 时，标准版会议接口直接拒绝**，并给出对应的 EB operation。
+ * 只拦"会议域且语义对得上"的 operation —— 其余的（登录、附件、二维码等）不涉及双套数据，放行。
+ */
+const STANDARD_TO_EB = {
+    'meeting.list': 'meeting.eb.meeting.list',
+    'meeting.detail.field': 'meeting.eb.meeting.detail',
+    'meeting.room.list': 'meeting.eb.room.list',
+    'meeting.room.usage': 'meeting.eb.roomUsage.list',
+    'meeting.type.list': 'meeting.eb.type.list',
+    'meeting.receipt.list': 'meeting.eb.receipt.list',
+    'meeting.sign.list': 'meeting.eb.sign.list',
+    'meeting.conflict.room': 'meeting.eb.conflict.room',
+    'meeting.conflict.member': 'meeting.eb.conflict.member',
+    'meeting.roomAttribute.list': 'meeting.eb.room.list',
+};
+/** 逃生开关：确认要看标准版数据时设 `WEAVER_MEETING_ALLOW_STANDARD_IN_EB=1`。 */
+function escapeEnabled() {
+    const flag = String(process.env.WEAVER_MEETING_ALLOW_STANDARD_IN_EB ?? '').trim().toLowerCase();
+    return flag === '1' || flag === 'true';
+}
+/**
+ * 标准版会议 operation 的环境守卫。
+ *
+ * 判据只用**已确认的**环境结论（env-mode 缓存）：
+ * - 缓存说 `eb` → 拒绝（本次事故场景）；
+ * - 缓存说 `standard` → 放行（这正是降级后的正常状态）；
+ * - **没有缓存 → 放行**。未探测不等于 EB：标准版租户首次使用不该被拦，
+ *   拦住反而会让"第一次就能用"的体验断掉。要纠偏就跑 `meeting.env.detect --refresh`。
+ */
+export async function assertStandardOperationAllowed(operation, context) {
+    const peer = STANDARD_TO_EB[operation];
+    if (!peer)
+        return;
+    if (escapeEnabled())
+        return;
+    let mode;
+    try {
+        const session = await context.host.getSession();
+        const cache = await readCache(context.ctx);
+        mode = cache.environments[session.baseUrl]?.mode;
+    }
+    catch {
+        // 缓存读不到（权限/损坏）不应阻断业务：按"未确认"处理，放行。
+        return;
+    }
+    if (mode !== 'eb')
+        return;
+    throw new MeetingCliError('api', 'env_mismatch', `当前环境已确认为 **EB 版**，\`${operation}\` 是**标准版**接口，返回的是另一套数据（两套会议数据互不相通，`
+        + '标准版会议室/会议在这里是不存在的东西）。请改用 EB operation **`' + peer + '`**。'
+        + '如果确实要读标准版数据（极少见），设环境变量 `WEAVER_MEETING_ALLOW_STANDARD_IN_EB=1` 后再跑。', {
+        code: 'env_mismatch',
+        details: {
+            requestedOperation: operation,
+            standardOperation: operation,
+            ebOperation: peer,
+            envMode: 'eb',
+        },
+        retryable: false,
+        exitCode: 1,
+    });
+}

package/dist/shortcuts/meeting/operations.js

@@ -3,6 +3,8 @@ import { dirname, join } from 'node:path';
 import { getMeetingOperation } from './operations/registry.js';
 import { assertNoForbiddenKeys, asObject } from './operations/shared.js';
 import { meetingStateDir } from './operations/env.js';
+import { tryDegradeEbFailure } from './operations/eb-fallback.js';
+import { assertStandardOperationAllowed } from './operations/standard-guard.js';
 /**
  * 调用流水（best-effort）：每次 operation 追加一行 JSON 到 `<state>/meeting/logs/calls.jsonl`。
  *
@@ -49,12 +51,26 @@ export async function executeMeetingOperation(operation, rawInput, context) {
     };
     const startedAt = Date.now();
     try {
+        // 环境守卫（2026-10-29）：环境已确认是 EB 时，标准版会议接口直接拒绝 ——
+        // 两套数据不通，标准版照常返回 74 间"不存在的会议室"，agent 会原样转述给用户。
+        await assertStandardOperationAllowed(operation, { ...context, host });
         const envelope = await definition.handler(input, { ...context, host });
         recordCall(context, operation, startedAt, true);
         return envelope;
     }
     catch (error) {
         recordCall(context, operation, startedAt, false, String(error?.type ?? 'unknown'));
+        // EB 优先 + 惰性降级：EB operation 在这个环境走不通时，实探标准版并把 standard 固化进
+        // env 缓存，然后抛 `env_fallback` 指引调用方改用标准版 operation。标准版也不通则保持原错误。
+        try {
+            const degraded = await tryDegradeEbFailure(operation, error, context.host, context.ctx);
+            if (degraded)
+                throw degraded;
+        }
+        catch (rethrow) {
+            if (rethrow !== error)
+                throw rethrow;
+        }
         throw error;
     }
 }

package/dist/shortcuts/workflow/endpoints.js

@@ -161,11 +161,16 @@ export const AJAX_QUERY = { sf_request_type: 'ajax' };
  * `/api/workflow/core/` 而原样返回，导致请求路径非法。
  *
  * - WEA_FORM（工作流表单）→ 保持 `FORM_ENDPOINTS` 默认地址
- * - WEA_EBUILDER（建模表单）→ `/api/workflow/core/` 段替换为 `/api/ebuilder/flow/`
+ * - WEA_EBUILDER（建模表单）→ `/api/workflow/core/` 段替换为 `ebPrefix`
+ *
+ * ⚠️ `ebPrefix` 默认 `/api/ebuilder/flow/`，但**建模表单内部前缀不统一**，必须按接口给
+ * （均为真机请求实证）：
+ * - `getFormLayout` / `getFormDataAndLayout` / `saveFormData` → `/api/ebuilder/flow/`
+ * - `executeFdLinkage` → `/api/ebuilder/form/`
  */
-export function formApiUrl(path, relateType) {
+export function formApiUrl(path, relateType, ebPrefix = '/api/ebuilder/flow/') {
     if (String(relateType || '').trim() === 'WEA_EBUILDER') {
-        return path.replace('/api/workflow/core/', '/api/ebuilder/flow/');
+        return path.replace('/api/workflow/core/', ebPrefix);
     }
     return path;
 }