weaver-work-cli 0.1.33 → 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, {
@@ -278,6 +367,11 @@ function buildReadOperation(endpoint) {
                 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,
@@ -285,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 } : {}),

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,6 +284,21 @@ 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) {
         if (roomData.rooms.length === 0) {
             // 2026-10-29 真机事故：0 间时只说了"放宽条件"，agent 转头去调标准版 meeting.room.list，

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

@@ -114,6 +114,10 @@ export async function tryDegradeEbFailure(operation, error, host, ctx) {
     // 手动开关：确认某环境就是 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))

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

@@ -136,6 +136,12 @@ async function probeAndPersist(host, ctx, knownEbError, options = {}) {
  */
 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 };

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/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;
 }