weaver-work-cli 0.1.28 → 0.1.31

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

@@ -32,6 +32,42 @@ function formatSecondNow() {
 const DECISION_DONE = '2';
 /** 会议状态「结束」：产生决议后会议即视为结束。 */
 const MT_STATUS_OVER = '8';
+/**
+ * **被取消过的会议**在「建决议 → 立刻标记已决议」时，ESB 会把同一批明细生成**两轮**任务。
+ *
+ * 2026-10-27 真机隔离（6 组对照）：
+ * | 会议状态 | create → mark 间隔 | 任务数（1 条明细） |
+ * |---|---|---|
+ * | 正常（未开始） | 立刻 | 1 ✅ |
+ * | 曾被取消 | 立刻 | **2** ❌ |
+ * | 曾被取消 | 500ms / 1s / 2s / 3s | 1 ✅ |
+ * | 曾被取消 | mark 前先只建决议、隔 3s 再标记 | 1 ✅ |
+ * | 正常发布后再取消 | — | 1 ✅（取消本身不重触发） |
+ *
+ * 窗口很短（<500ms），故对"曾取消"的会议在两步之间插 800ms 余量；正常会议不加延迟。
+ */
+const CANCELLED_MARK_DELAY_MS = 800;
+/** 会议是否处于「已取消」状态（mt_status=4/名称含"取消"，或 operate_type 仍留着 CANCEL）。读不到就按未取消处理。 */
+async function isCancelledMeeting(env, mtId) {
+    try {
+        const { getMeetingOperation } = await import('../registry.js');
+        const listed = await getMeetingOperation('meeting.eb.meeting.list').handler(
+        // withCount:false —— 这里只要一行状态，不必额外请求 count（少一次往返，也便于测试替身）
+        { mt_id: mtId, pageNo: 1, pageSize: 1, withCount: false }, env);
+        const row = (listed?.data?.rows ?? [])[0] ?? {};
+        const main = row.mainTable ?? row;
+        const status = main?.mt_status;
+        const statusId = typeof status === 'object' && status !== null ? String(status.id ?? '') : String(status ?? '');
+        const statusName = typeof status === 'object' && status !== null ? String(status.name ?? '') : String(status ?? '');
+        // ⚠️ 实测：取消后再发布决议，mt_status 会被写成"结束"，唯独 operate_type 一直留着 CANCEL
+        // ⇒ 只判 mt_status 会漏（我第一次改就漏了），必须同时看 operate_type。
+        const operateType = String(main?.operate_type ?? '').toUpperCase();
+        return statusId === '4' || statusName.includes('取消') || operateType.includes('CANCEL');
+    }
+    catch {
+        return false;
+    }
+}
 function requireEndpoint(interfacePk) {
     const endpoint = EB_ENDPOINTS.find((item) => item.interfacePk === interfacePk);
     if (!endpoint)
@@ -187,6 +223,9 @@ const decisionPublishApply = {
         }
         const session = await env.host.getSession();
         const { create, mtId, mtStatus } = payload;
+        // 被取消过的会议：两步之间必须留间隔，否则 ESB 会把同一批明细生成两轮任务（见 CANCELLED_MARK_DELAY_MS）
+        const cancelled = await isCancelledMeeting(env, mtId);
+        const warnings = [];
         // 第 1 步：写决议概述 + 明细
         // ⚠️ 真机教训（2026-09-21）：EB 写接口**报错不等于没写库** —— 实测一次因字段校验失败
         // （data_status 不被接受）的 create_mt_decision，主表与明细其实已经落库；调用方若把"报错"
@@ -223,6 +262,13 @@ const decisionPublishApply = {
                 + `请先用 meeting.eb.decision.list({ mt_id: "${mtId}" }) 回查该会议是否已生成决议，再决定是否单独调用 meeting.eb.meeting.markDecided 标记；**不要**重复创建决议。`, { mtId, attempted: { interfacePk: 'create_mt_decision', body: create } }, { stage: applyName });
         }
         // 第 2 步：写回会议（关联决议 + 决议状态 + 会议状态）
+        // ⚠️ 曾取消的会议：紧接着调用会让 ESB 触发两轮（真机：1 条明细 → 2 条任务）。
+        // 实测 500ms 即够，这里留 800ms 余量；正常会议不走这个分支，不增加耗时。
+        if (cancelled) {
+            await new Promise((resolve) => { setTimeout(resolve, CANCELLED_MARK_DELAY_MS); });
+            warnings.push('该会议此前被取消过：已在「写决议」与「标记已决议」之间留 '
+                + `${CANCELLED_MARK_DELAY_MS}ms 间隔，避免 ESB 把同一批明细生成两轮任务（真机验证过的坑）`);
+        }
         const markMainTable = { id: mtId, decision_Id: decisionId, is_decision: DECISION_DONE, mt_status: mtStatus };
         const markPayload = { mainTable: markMainTable, details: {}, operateType: {} };
         try {
@@ -250,7 +296,7 @@ const decisionPublishApply = {
             isDecision: DECISION_DONE,
             mtStatus,
             result: createResponse,
-        });
+        }, warnings.length > 0 ? { warnings } : {});
     },
 };
 const signMarkPrepare = {

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { meetingConfirmationError, meetingPartialError, meetingValidationError } from '../../errors.js';
 import { meetingSuccess, SCHEMA_ID } from '../types.js';
-import { assertDateTimeMinute, assertDateTimeSecond, toIdString } from '../shared.js';
+import { assertDate, assertDateTimeMinute, assertDateTimeSecond, toIdString } from '../shared.js';
 import { isWriteKind } from './catalog.js';
 /** EB（eBuilder formdata）通用路径前缀（资料核实）。 */
 export const EB_BASE = '/api/ebuilder/form/formdata/v2';
@@ -109,6 +109,11 @@ export function extractEbRows(response) {
         const total = typeof dj?.total === 'number' ? dj.total : typeof value?.total === 'number' ? value.total : undefined;
         return { rows: raw, ...(total === undefined ? {} : { total }) };
     }
+    // EB 个别接口会把单条记录的对象（而非数组）直接放进 datas —— 按一行处理，
+    // 否则会静默变成 0 行，调用方拿着"未找到"继续往下走（2026-10-28 排查明细透出时的同类隐患）。
+    if (raw !== null && typeof raw === 'object') {
+        return { rows: [raw] };
+    }
     return { rows: [] };
 }
 /** 从 count 响应中取总数（datajson.datas 为数值）。 */
@@ -174,12 +179,22 @@ function buildReadOperation(endpoint) {
                 // EB 的 getFormDataByPk 与 list 一致，把数据放在 `datajson.datas[].mainTable`。
                 // 早期实现直接返回整个 datajson → data 变成 `{datas,status}`（2026-09-21 真机发现）。
                 const { rows } = extractEbRows(response);
-                const data = rows[0]?.mainTable ?? response?.datajson?.mainTable ?? null;
+                const row = rows[0] ?? null;
+                const data = row?.mainTable ?? response?.datajson?.mainTable ?? null;
                 if (data === undefined || data === null) {
                     // 不存在的 id 必须明确报「未找到」，否则调用方会拿着空对象继续往下走。
                     throw meetingValidationError('not_found', `${endpoint.interfacePk} 未找到 id=${id} 的数据（可能已被删除，或当前账号无权限）`, { id, interfacePk: endpoint.interfacePk });
                 }
-                return meetingSuccess(endpoint.operation, { id, data }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
+                // 行内 mainTable 之外的节点即明细（detail1/detail2/…）。接口配置了返回明细时
+                // 会出现在这里——原实现直接丢弃，导致"接口明明回了明细、CLI 却看不见"（2026-10-28）。
+                const detailNodes = {};
+                if (row) {
+                    for (const [key, value] of Object.entries(row)) {
+                        if (key !== 'mainTable')
+                            detailNodes[key] = value;
+                    }
+                }
+                return meetingSuccess(endpoint.operation, { id, data, ...(Object.keys(detailNodes).length > 0 ? { details: detailNodes } : {}) }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
             }
             const query = {};
             for (const param of endpoint.queryParams ?? []) {
@@ -248,15 +263,30 @@ function buildReadOperation(endpoint) {
                 : summarized !== null && typeof summarized === 'object'
                     ? { ...summarized, page: pageMeta }
                     : { value: summarized, page: pageMeta };
+            // ⚠️ 分页提示：本页条数 < 总数时明确告诉调用方"还有没取到的"，
+            // 避免只看本页就下结论（2026-10-23 我本人就因此误判"该环境只有 10 个会议"，
+            // 实际 total=46，只是第一页 + stdout 预览把数组截到 10 条）。
+            // 注意：EB 服务端**不会**压低 pageSize（pageSize=50/200 都能一次拿全 46 条），
+            // 所以这里只提示翻页/加大 pageSize，不要写成"服务端限制"。
+            const effectiveTotal = Math.max(resolvedTotal, rows.length);
+            const pageWarnings = [];
+            if (effectiveTotal > rows.length) {
+                const missing = effectiveTotal - rows.length;
+                pageWarnings.push(`本页返回 ${rows.length} 条，共 ${effectiveTotal} 条：还有 ${missing} 条未取到。`
+                    + `需要全量请翻页（pageNo=${pageNo + 1} 起）或加大 pageSize，或收窄筛选条件`);
+            }
             return meetingSuccess(endpoint.operation, {
-                total: Math.max(resolvedTotal, rows.length),
+                total: effectiveTotal,
                 pageNo,
                 pageSize,
                 count: rows.length,
                 ...(progress ? { progress } : {}),
                 rows,
                 filters: query,
-            }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
+            }, {
+                ...(endpoint.notes ? { meta: { notes: endpoint.notes } } : {}),
+                ...(pageWarnings.length > 0 ? { warnings: pageWarnings } : {}),
+            });
         },
     };
 }
@@ -271,6 +301,8 @@ function writePkQuery(endpoint, payload) {
     // delete 一律把主键放 URL：真机实测 `delete_roomusage` 只在 body 传 id 会报「主键传入不能为空」
     // （与 `update_meeting_sign_info` 同因）；update 按接口的 pkQueryParam 声明。
     // 多带一个 `?id=` 对已支持 body 主键的接口无害（`room.delete` / `update_room` 均已实测通过）。
+    if (endpoint.kind === 'delete' && endpoint.batchDeleteFields)
+        return undefined;
     const param = endpoint.pkQueryParam ?? (endpoint.kind === 'delete' ? 'id' : undefined);
     if (!param)
         return undefined;
@@ -352,7 +384,9 @@ function normalizeDetailRow(spec, row, index) {
  * 只报“缺少必填字段”会让调用方无从下手。
  */
 export function normalizeEbWrite(endpoint, args, userId) {
-    const fields = endpoint.kind === 'delete' ? ['id'] : endpoint.fields ?? [];
+    const fields = endpoint.kind === 'delete'
+        ? (endpoint.batchDeleteFields ?? ['id'])
+        : endpoint.fields ?? [];
     const mainTable = {};
     for (const field of fields) {
         const value = args[field];
@@ -364,10 +398,23 @@ export function normalizeEbWrite(endpoint, args, userId) {
         else if ((endpoint.secondDateFields ?? []).includes(field)) {
             mainTable[field] = assertDateTimeSecond(value, field);
         }
+        else if ((endpoint.dateOnlyFields ?? []).includes(field)) {
+            // 纯日期（如议题的 proposal_date，真机存的是 2026-10-23）
+            mainTable[field] = assertDate(value, field);
+        }
         else {
             mainTable[field] = value;
         }
     }
+    // create 的字段默认值：EB 漏传 Select 字段时**不是留空**，而是落成接口配置的默认项
+    // （真机：create_room 漏传 status 建出「封存」的会议室）。只对 create 生效，
+    // update 补默认值等于擅自改用户没提的字段。
+    if (endpoint.kind === 'create' && endpoint.fieldDefaults) {
+        for (const [field, value] of Object.entries(endpoint.fieldDefaults)) {
+            if (mainTable[field] === undefined)
+                mainTable[field] = value;
+        }
+    }
     if (endpoint.interfacePk === 'create_meeting') {
         if (mainTable.caller === undefined)
             mainTable.caller = userId;
@@ -379,7 +426,9 @@ export function normalizeEbWrite(endpoint, args, userId) {
         if (hours !== undefined)
             mainTable.mt_hours = hours;
     }
-    const required = endpoint.kind === 'delete' ? ['id'] : endpoint.requiredFields ?? [];
+    const required = endpoint.kind === 'delete'
+        ? (endpoint.batchDeleteFields ?? ['id'])
+        : endpoint.requiredFields ?? [];
     const missing = required.filter((field) => mainTable[field] === undefined);
     if (missing.length > 0) {
         throw meetingValidationError('missing_required_field', `缺少必填字段：${missing.join(', ')}`, { missing });
@@ -404,7 +453,26 @@ export function normalizeEbWrite(endpoint, args, userId) {
         if (rows.length > 0)
             details[spec.node] = rows;
     }
-    return { mainTable, details, operateType: {} };
+    // 明细写入模式：默认「更新追加」（EB 不传 operateType 时的行为）；只有声明了 detailCover 的接口才允许 cover。
+    const operateType = {};
+    const detailMode = args.detail1Mode;
+    if (detailMode !== undefined && detailMode !== null && detailMode !== '') {
+        if (!endpoint.detailCover) {
+            throw meetingValidationError('unsupported_detail_mode', `${endpoint.interfacePk} 不支持 detail1Mode（该接口未声明明细覆盖能力），请去掉该参数按默认追加写入`, { interfacePk: endpoint.interfacePk });
+        }
+        if (detailMode !== 'append' && detailMode !== 'cover') {
+            throw meetingValidationError('invalid_detail_mode', `detail1Mode 只能是 append（追加，默认）或 cover（覆盖：传几行就只剩几行）`, { detail1Mode: String(detailMode) });
+        }
+        if (detailMode === 'cover') {
+            // 只对**真正带了明细**的节点生效：没传 detail1 却要求 cover，等同于"清空全部明细"，不允许。
+            if (Object.keys(details).length === 0) {
+                throw meetingValidationError('invalid_detail_mode', 'detail1Mode=cover 时必须同时传 detail1（至少 1 行）：cover 会覆盖整组明细，空数组等于把明细全删掉', { node: 'detail1' });
+            }
+            for (const node of Object.keys(details))
+                operateType[node] = 'cover';
+        }
+    }
+    return { mainTable, details, operateType };
 }
 function buildWriteInputSchema(endpoint, includeConfirm) {
     const properties = {};
@@ -413,7 +481,15 @@ function buildWriteInputSchema(endpoint, includeConfirm) {
         properties.continuation = { type: 'string', minLength: 1 };
     }
     if (endpoint.kind === 'delete') {
-        properties.id = { ...SCHEMA_ID, description: '数据主键 id（必填）' };
+        if (endpoint.batchDeleteFields && endpoint.batchDeleteFields.length > 0) {
+            // 批量删除：按业务条件删（如 delete_roomusage 的 mt_id），不是主键
+            for (const field of endpoint.batchDeleteFields) {
+                properties[field] = { type: 'string', description: `${field}（删除条件，该接口按它批量删除）` };
+            }
+        }
+        else {
+            properties.id = { ...SCHEMA_ID, description: '数据主键 id（必填）' };
+        }
     }
     else {
         for (const field of endpoint.fields ?? []) {
@@ -448,9 +524,16 @@ function buildWriteInputSchema(endpoint, includeConfirm) {
                 },
             };
         }
+        if (endpoint.detailCover) {
+            properties.detail1Mode = {
+                type: 'string',
+                enum: ['append', 'cover'],
+                description: '明细写入模式：append=追加（默认，老明细保留）／cover=覆盖（整组替换，传几行就只剩几行）',
+            };
+        }
     }
     const requiredBase = endpoint.kind === 'delete'
-        ? ['id']
+        ? (endpoint.batchDeleteFields ?? ['id'])
         : [
             ...(endpoint.requiredFields ?? []),
             ...(endpoint.details ?? []).filter((spec) => (spec.minRows ?? 0) > 0).map((spec) => spec.node),
@@ -464,6 +547,22 @@ function buildWriteInputSchema(endpoint, includeConfirm) {
         required: includeConfirm ? ['confirm', 'continuation'] : requiredBase,
     };
 }
+/** 查员工所属部门 id（`create_mt_topic` 的 `proposal_dept` 默认值用）。失败静默返回 null，不阻塞创建。 */
+async function lookupEmployeeDepartmentId(env, userId) {
+    try {
+        const { hrmEmployeeOperations } = await import('../../../hrm/operations/employee.js');
+        const batch = hrmEmployeeOperations.find((operation) => operation.name === 'hrm.employee.batch');
+        if (!batch)
+            return null;
+        const result = await batch.handler({ ids: [userId] }, env);
+        const row = (result?.data?.rows ?? [])[0];
+        const deptId = String(row?.departmentId ?? '').trim();
+        return deptId || null;
+    }
+    catch {
+        return null;
+    }
+}
 function buildWriteOperations(endpoint, preflight, afterWrite) {
     const prepareName = `${endpoint.operation}.prepare`;
     const applyName = `${endpoint.operation}.apply`;
@@ -484,8 +583,26 @@ function buildWriteOperations(endpoint, preflight, afterWrite) {
         handler: async (args, env) => {
             const session = await env.host.getSession();
             const payload = normalizeEbWrite(endpoint, args, session.userId);
+            // 议题库创建默认值（2026-10-28 用户口径）：提议人员/提议单位不该留空——
+            // 默认当前人员 + 其所属部门 id（查不到部门就静默跳过，不阻塞创建）。
+            if (endpoint.interfacePk === 'create_mt_topic') {
+                if (payload.mainTable.proposal_person === undefined)
+                    payload.mainTable.proposal_person = session.userId;
+                if (payload.mainTable.proposal_dept === undefined) {
+                    const deptId = await lookupEmployeeDepartmentId(env, session.userId);
+                    if (deptId)
+                        payload.mainTable.proposal_dept = deptId;
+                }
+            }
             // EB 版建会缺少强制冲突检测会重复占用会议室/参会人撞会，故 prepare 阶段由钩子补齐。
-            const warnings = preflight ? await preflight({ endpoint, args, payload, env }) : [];
+            const extras = {};
+            const warnings = preflight ? await preflight({ endpoint, args, payload, env, extras }) : [];
+            // 支持明细覆盖的接口（如 update_mt_decision）默认是「更新追加」：真机实测同 sort_number 也会**新增一行**。
+            // 调用方最容易在这里理解错，故 prepare 就明确提示，而不是等回读发现多了一行。
+            if (endpoint.detailCover && Object.keys(payload.details).length > 0 && payload.operateType.detail1 !== 'cover') {
+                warnings.push('detail1 默认是「更新追加」：本次会新增明细行，**不会**覆盖 sort_number 相同的旧行'
+                    + '（真机实测：2 行 → 传 1 行 → 变 3 行）。要整组替换请传 detail1Mode: "cover"');
+            }
             const token = await env.continuation.issue({
                 operation: applyName,
                 baseUrl: session.baseUrl,
@@ -503,6 +620,7 @@ function buildWriteOperations(endpoint, preflight, afterWrite) {
                     path: pathWithPk(endpoint, path, payload),
                     notes: endpoint.notes ?? [],
                 },
+                ...(Object.keys(extras).length > 0 ? { decisions: extras } : {}),
                 continuation: token,
                 expiresInSeconds: CONTINUATION_TTL_SECONDS,
             }, warnings.length > 0 ? { warnings } : {});

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

@@ -3,6 +3,10 @@ import { buildEbOperations } from './factory.js';
 import { ebMeetingWritePreflight, meetingEbConflictOperations } from './conflict.js';
 import { meetingEbDecisionOperations } from './decision.js';
 import { ebMeetingAssociation } from './association.js';
+import { ebRoomRecommendOperation, recommendRooms, rememberFrequentRoom } from './room-recommend.js';
+import { meetingValidationError } from '../../errors.js';
+import { meetingEbScheduleOperations } from './schedule.js';
+import { meetingEbCreateFlowOperations } from './create-flow.js';
 /**
  * 会议 EB 版（eBuilder）operations。
  *
@@ -28,12 +32,128 @@ import { ebMeetingAssociation } from './association.js';
  * - `ebMeetingAssociation` 挂到 apply 之后：`create_meeting` 只写会议主表，**不会**生成
  *   占用 / 回执 / 签到，而这三样是会议室冲突检测、参会人冲突检测与补签的硬依赖，故由 CLI 补齐
  *   （见 association.ts：主写入已成功，补建失败只回报 warnings，不中断）。
+ *
+ * 日程空闲 + 会议室推荐 + 建会自动化（2026-10-28 新增，用户明确要求）：
+ * - `meetingEbScheduleOperations`：`meeting.eb.schedule.free` 查**日程应用**（ESB 动作流），
+ *   与 `conflict.member`（查会议表）是两件事，别混；
+ * - `ebRoomRecommendOperation`：按人数/要求/个人常用/时段占用推荐会议室，含两级本地缓存；
+ * - `ebAutoRoomPreflight`：建会没填会议室 → 自动推荐并写入（在冲突检测之前，选中房间照样过校验）；
+ *   关掉用 `WEAVER_MEETING_AUTO_ROOM=0`；
+ * - `ebAutoInvitationAfterWrite`：建会成功后**直接生成邀请函**，路径在 `data.association.invitation`，
+ *   失败只回 warning 不中断；关掉用 `WEAVER_MEETING_AUTO_INVITATION=0`。
  */
+/** 建会未指定会议室时的自动推荐（包在冲突检测外层：先选房，再按选中房间校验冲突）。 */
+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';
+    // 会议室策略（用户口径）：**不替用户决定** —— 没填会议室就列候选让用户选。
+    // - WEAVER_MEETING_AUTO_ROOM=1  显式开启"自动选推荐间"（自动化场景）
+    // - WEAVER_MEETING_AUTO_ROOM=0  不推荐也不拦（线上会/无会议室场景）
+    // - 未设置（默认）            返回 session 级候选，prepare 抛 room_selection_required 带候选
+    const mode = String(process.env.WEAVER_MEETING_AUTO_ROOM ?? '').trim();
+    if (isCreate && !context.payload.mainTable.address && mode !== '0') {
+        const begin = String(context.payload.mainTable.begin_datetime ?? '').trim();
+        const end = String(context.payload.mainTable.end_datetime ?? '').trim();
+        const memberCount = String(context.payload.mainTable.hrm_members ?? '')
+            .split(/[,;，；\s]+/)
+            .map((item) => item.trim())
+            .filter((item) => item !== '').length;
+        if (begin && end) {
+            try {
+                const result = await recommendRooms(context.env, {
+                    beginDatetime: begin,
+                    endDatetime: end,
+                    ...(memberCount > 0 ? { memberCount } : {}),
+                    topN: 5,
+                });
+                const roomOptions = result.candidates.map((candidate, index) => ({
+                    key: `R${index + 1}`,
+                    label: `${candidate.name}${candidate.capacity.max > 0 ? `（可容 ${candidate.capacity.max} 人）` : ''}`
+                        + `${index === 0 ? ' · 推荐' : ''}`,
+                    value: { id: candidate.id, name: candidate.name },
+                    reason: candidate.reasons.join('；'),
+                }));
+                extras.autoRoom = {
+                    picked: null,
+                    candidates: result.candidates,
+                    meta: result.meta,
+                };
+                extras.roomOptions = roomOptions;
+                if (mode === '1' && result.best) {
+                    // 仅显式开启时才自动写入
+                    context.payload.mainTable.address = result.best.id;
+                    extras.autoRoom = {
+                        picked: { id: result.best.id, name: result.best.name, score: result.best.score, reasons: result.best.reasons },
+                        candidates: result.candidates,
+                        meta: result.meta,
+                    };
+                    warnings.push(`已按 WEAVER_MEETING_AUTO_ROOM=1 自动选择「${result.best.name}」（${result.best.reasons.join('；')}）；`
+                        + '不认可请重新 prepare 并显式传 address。');
+                }
+                else if (roomOptions.length > 0) {
+                    throw meetingValidationError('room_selection_required', `未指定会议室：请从 ${roomOptions.length} 个候选中选择一个（按人数/常用/时段占用排序），`
+                        + '把选中的 id 作为 address 重新 prepare。若这场会不需要会议室，设置 WEAVER_MEETING_AUTO_ROOM=0 后重试。', { roomOptions, meta: result.meta });
+                }
+                else {
+                    warnings.push(...result.warnings);
+                }
+            }
+            catch (error) {
+                if (error?.subtype === 'room_selection_required')
+                    throw error;
+                warnings.push(`会议室推荐失败（${String(error?.message ?? error).slice(0, 80)}）：本次不填会议室继续，请与用户确认地点`);
+            }
+        }
+        else {
+            warnings.push('会议开始/结束时间不完整，跳过会议室推荐');
+        }
+    }
+    const conflictWarnings = await ebMeetingWritePreflight(context);
+    warnings.push(...conflictWarnings);
+    return warnings;
+};
+/** 建会成功后自动生成邀请函（失败只回报，绝不中断建会）。 */
+const ebAutoInvitationAfterWrite = async (context) => {
+    const association = await ebMeetingAssociation(context);
+    // 建会成功即把该会议室计入「个人常用」缓存：用户今天连开几场，推荐偏好当天就变，
+    // 不必等 7 天 TTL 过期重算（2026-10-28 用户明确要求）。
+    if (context.endpoint.interfacePk === 'create_meeting') {
+        const roomId = String(context.payload.mainTable.address ?? '').trim();
+        if (roomId)
+            await rememberFrequentRoom(context.env, roomId).catch(() => false);
+    }
+    const enabled = String(process.env.WEAVER_MEETING_AUTO_INVITATION ?? '1') !== '0';
+    const isCreate = context.endpoint.kind === 'create' && context.endpoint.interfacePk === 'create_meeting';
+    const mtId = String(context.dataIds?.[0] ?? '').trim();
+    if (!isCreate || !enabled || !mtId)
+        return association;
+    try {
+        const { getMeetingOperation } = await import('../registry.js');
+        const render = getMeetingOperation('meeting.invitation.render');
+        const result = await render.handler({ mtId }, context.env);
+        return { ...(association ?? {}), invitation: result?.data ?? null };
+    }
+    catch (error) {
+        return {
+            ...(association ?? {}),
+            invitation: {
+                ok: false,
+                error: String(error?.message ?? error).slice(0, 200),
+                hint: '会议已建好；邀请函生成失败不影响建会，可稍后单独调用 meeting.invitation.render',
+            },
+        };
+    }
+};
 export const meetingEbOperations = [
     ...buildEbOperations(EB_ENDPOINTS, {
-        preflight: ebMeetingWritePreflight,
-        afterWrite: ebMeetingAssociation,
+        preflight: ebAutoRoomPreflight,
+        afterWrite: ebAutoInvitationAfterWrite,
     }),
     ...meetingEbConflictOperations,
     ...meetingEbDecisionOperations,
+    ...meetingEbScheduleOperations,
+    ...meetingEbCreateFlowOperations,
+    ebRoomRecommendOperation,
 ];