weaver-work-cli 0.1.29 → 0.1.32

package/dist/shortcuts/meeting/operations/from-group-chat.js

@@ -0,0 +1,576 @@
+/**
+ * 群聊消息 → 会议纪要（一条命令跑完）。
+ *
+ * 背景（2026-10-26 真机跑通，2026-10-27 固化为操作）：
+ * 会议记录里带 `imchat_groupid`，正常用法是**拿着会议生成纪要**，而不是拿群反查会议。
+ *
+ * ```
+ * 会议 id → imchat_groupid
+ *   → im.msg.sync.group 拉消息（**返回倒序，必须按 msgtime 升序重排**）
+ *   → 过滤 typeName=通知 的系统消息（可选保留）
+ *   → sender='我' 换真名（im.person.resolveByIds，按 from_uid）
+ *   → 拼「时间 说话人：内容」
+ *   → 建纪要（minutes_content, status=4）
+ *   → [pipeline=minutes]  ESB 633 生成纪要文案 → parse_content, status=1
+ *   → [pipeline=document] ESB 628 生成文档 → mt_minutes + status=2
+ * ```
+ *
+ * ⚠️ 实测耗时（11 条消息）：拉消息 2.1s、拼原文 1.3s、建纪要 0.6s，
+ * 但 **ESB 633 生成纪要文案要 37s 左右** —— 这是最慢的一步，不是卡死。
+ *
+ * ⚠️ `mtAIMinutePageID` 是租户级固定值（本环境 `1325287772302860413`），没有接口能查。
+ * 这里不写死：优先用入参，其次从该会议已有纪要里反查，都拿不到就留空并给 warning。
+ */
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess } from './types.js';
+/** ESB 动作流 id 的**内置默认值**（参考租户配置）。换租户请用入参 `flowGenerateMinutes` / `flowGenerateDocument` 覆盖。 */
+const FLOW_GENERATE_MINUTES = '1325287772302863633';
+const FLOW_GENERATE_DOCUMENT = '1325287772302863628';
+function textOf(value) {
+    return value === undefined || value === null ? '' : String(value);
+}
+const DAY_MS = 24 * 3600_000;
+/** 解析 E10 的本地时间串；只给日期时补 `00:00:00`，否则会得到 Invalid Date 静默退回默认窗口。 */
+function parseLocalTime(value) {
+    const text = textOf(value).trim();
+    if (!text)
+        return null;
+    const normalized = /^\d{4}-\d{2}-\d{2}$/u.test(text)
+        ? `${text} 00:00:00`
+        : text.length <= 16
+            ? `${text}:00`
+            : text;
+    const parsed = new Date(normalized.replace(/-/g, '/'));
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function formatStamp(d) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} `
+        + `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+/**
+ * 群聊默认时间窗。⚠️ im 模块默认只拉「当天」，而群里分工多是**会前**发的，
+ * 只拉当天会漏；窗口也别无限放大（im 侧最多 7 天）。
+ *
+ *   from = max(会议创建时间, 会议开始前 7 天)   —— 覆盖会前在群里分工的那几天
+ *   to   = min(现在, 会议结束后 2 小时)          —— 覆盖会后收尾，但不拉到未来
+ *
+ * 抽成纯函数是为了 `meeting.summary`（只读）能复用同一套口径，不复制粘贴。
+ */
+export function computeChatWindow(meeting, now = new Date()) {
+    const begin = parseLocalTime(meeting.begin_datetime);
+    const end = parseLocalTime(meeting.end_datetime);
+    const created = parseLocalTime(meeting.create_time);
+    const fromCandidates = [created, begin ? new Date(begin.getTime() - 7 * DAY_MS) : null]
+        .filter((item) => item !== null);
+    const windowFrom = fromCandidates.length > 0
+        ? new Date(Math.max(...fromCandidates.map((d) => d.getTime())))
+        : new Date(now.getTime() - 7 * DAY_MS);
+    const toCandidates = [now, end ? new Date(end.getTime() + 120 * 60_000) : null]
+        .filter((item) => item !== null);
+    const windowTo = new Date(Math.min(...toCandidates.map((d) => d.getTime())));
+    return { from: formatStamp(windowFrom), to: formatStamp(windowTo) };
+}
+/**
+ * 大消息量保护：群里几千几万条时，既不能把 CLI 拖死，也不能把 ESB 633 撑爆
+ * （它要把 minutes_content 整段喂给模型）。这里做**采样去噪**，规则透明可解释：
+ *
+ * 1. 必留：被 @ 的消息、含任务/决策关键词的消息、系统通知（若 keepSystem）；
+ * 2. 丢：纯表情/单字回复（嗯、好、收到…）、连续同人重复、正文过短的灌水；
+ * 3. 每人每 N 条最多留 M 条，保证不同人的声音都在，但不被刷屏者淹没。
+ *
+ * 采样是**显式**的：返回 `sampled: true` 与 `kept/total`，让调用方如实告诉用户"已采样"。
+ */
+const NOISE_MAX_LEN = 4;
+const NOISE_WORDS = new Set([
+    '嗯', '恩', '好', '好的', '好滴', '收到', 'ok', 'OK', 'Ok', '行', '可以', '对的', '是的',
+    '在', '在的', '哈哈', '哈哈哈', '谢谢', '拜拜', '早', '晚安', '1', '？', '?', '。。。',
+]);
+const KEYWORD_PATTERN = /(负责|决定|结论|确定|定稿|截止|之前|完成|上线|提测|风险|问题|方案|需求|排期|汇报|跟进|@)/;
+function isNoise(content) {
+    const text = content.trim();
+    if (text.length === 0)
+        return false; // 非文本消息由上层占位处理，不在此丢弃
+    if (text.length <= NOISE_MAX_LEN && NOISE_WORDS.has(text))
+        return true;
+    // 纯表情/纯标点
+    if (/^[\p{Emoji}\p{P}\s]+$/u.test(text))
+        return true;
+    return false;
+}
+/** 按「必留 / 去噪 / 每人限额」采样，返回保留下来的消息（保持原顺序）。 */
+export function sampleMessages(messages, perSenderLimit = 60) {
+    const kept = [];
+    const perSender = new Map();
+    let dropped = 0;
+    let lastSpeaker = '';
+    let lastContent = '';
+    for (const message of messages) {
+        const content = textOf(message.content).trim();
+        const speaker = textOf(message.from_uid) || textOf(message.sender);
+        const mustKeep = KEYWORD_PATTERN.test(content);
+        if (!mustKeep) {
+            // 连续同一人复读同样内容 → 丢
+            if (speaker === lastSpeaker && content !== '' && content === lastContent) {
+                dropped += 1;
+                continue;
+            }
+            if (isNoise(content)) {
+                dropped += 1;
+                lastSpeaker = speaker;
+                lastContent = content;
+                continue;
+            }
+            const used = perSender.get(speaker) ?? 0;
+            if (used >= perSenderLimit) {
+                dropped += 1;
+                continue;
+            }
+            perSender.set(speaker, used + 1);
+        }
+        kept.push(message);
+        lastSpeaker = speaker;
+        lastContent = content;
+    }
+    return { kept, dropped };
+}
+/** 单条消息 → 一行纪要原文。非文本消息只占位，**不编造内容**。 */
+function formatLine(message, nameByUid) {
+    const speaker = nameByUid[textOf(message.from_uid)] || textOf(message.sender) || '未知';
+    const content = textOf(message.content).trim();
+    if (content)
+        return `${textOf(message.time)} ${speaker}：${content}`;
+    const media = Array.isArray(message.media) && message.media.length > 0 ? message.media[0] : null;
+    return `${textOf(message.time)} ${speaker}：[${media ? '附件/图片' : '无文字内容'}]`;
+}
+/**
+ * 把群消息整理成纪要原文。抽成纯函数是为了能离线单测 ——
+ * 排序方向、系统消息过滤、空内容占位这三条口径都踩过坑，必须有断言守着。
+ *
+ * 返回 `{ transcript, kept, ignoredSystem }`；`kept` 是保留下来的条数。
+ */
+export function composeTranscript(messages, nameByUid, keepSystem) {
+    // ⚠️ im.msg.sync.group 返回是**倒序（新→旧）**，不重排会把纪要时间线写反
+    const ordered = [...messages].sort((a, b) => Number(a.msgtime ?? 0) - Number(b.msgtime ?? 0));
+    const keptMessages = keepSystem ? ordered : ordered.filter((m) => textOf(m.typeName) !== '通知');
+    const ignoredSystem = ordered.length - keptMessages.length;
+    return {
+        transcript: keptMessages.map((message) => formatLine(message, nameByUid)).join('\n'),
+        kept: keptMessages.length,
+        ignoredSystem,
+    };
+}
+// ---------------------------------------------------------------------------
+// 摘要版（用户 2026-10-27 选定方案 B）
+//
+// 采样压完仍超上限时（几万条那种群），不能把几十万字塞给 ESB 633 —— 它不是
+// "慢"，是**会被撑爆**。这里只保留"分工 / 结论 / 待办"这类有决策价值的发言，
+// 并明确标注这是摘要版；完整原文另存文件，供需要时人工查阅。
+// ---------------------------------------------------------------------------
+const DIGEST_PATTERN = /(@|负责|分工|安排|决定|结论|确定|定稿|通过|不同意|同意|截止|完成|上线|提测|排期|汇报|跟进|待办|风险|问题|方案|需求|下周|本周|明天|后天|月底|之前|号前)/;
+/** 只保留有决策价值的发言，压成摘要版；仍超上限则按行截断。 */
+export function buildDigest(messages, nameByUid, keepSystem, maxChars) {
+    const ordered = [...messages].sort((a, b) => Number(a.msgtime ?? 0) - Number(b.msgtime ?? 0));
+    const base = keepSystem ? ordered : ordered.filter((m) => textOf(m.typeName) !== '通知');
+    const essence = base.filter((message) => {
+        const content = textOf(message.content).trim();
+        if (!content)
+            return false; // 摘要版里占位行没有信息量
+        return DIGEST_PATTERN.test(content);
+    });
+    const dropped = base.length - essence.length;
+    const header = `【群聊摘要：共 ${base.length} 条消息，仅保留与分工/结论/待办相关的 ${essence.length} 条，省略 ${dropped} 条】`;
+    let lines = essence.map((message) => formatLine(message, nameByUid));
+    let truncated = false;
+    let transcript = [header, ...lines].join('\n');
+    if (transcript.length > maxChars) {
+        // 按行截断，避免切在句子中间；保留最早的发言（通常是分工与背景）
+        const kept = [];
+        let used = header.length + 1;
+        for (const line of lines) {
+            if (used + line.length + 1 > maxChars)
+                break;
+            kept.push(line);
+            used += line.length + 1;
+        }
+        truncated = true;
+        lines = kept;
+        transcript = [header, ...kept, `…（以下省略 ${essence.length - kept.length} 条，原文过长）`].join('\n');
+    }
+    return { transcript, kept: lines.length, dropped, truncated };
+}
+/**
+ * 完整原文落盘。摘要版一旦启用，用户很可能想核原文 —— 不能只在返回值里
+ * 留一句"已省略"，得给一个真能打开的路径。
+ * 落在 CLI state 目录（不进工作区，避免污染用户仓库）。
+ */
+async function saveTranscript(ctx, mtId, transcript) {
+    const { mkdir, writeFile } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const { stateDir } = await import('../../../core/state.js');
+    const dir = join(stateDir(ctx), 'transcripts');
+    await mkdir(dir, { recursive: true });
+    const pad = (n) => String(n).padStart(2, '0');
+    const now = new Date();
+    const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const filePath = join(dir, `${mtId}-${stamp}.txt`);
+    await writeFile(filePath, transcript, 'utf8');
+    return filePath;
+}
+const meetingMinuteFromGroupChat = {
+    name: 'meeting.minute.fromGroupChat',
+    resource: 'minute',
+    method: 'fromGroupChat',
+    action: 'meeting.minute.fromGroupChat',
+    summary: '把会议关联群聊的消息整理成纪要：拉消息→按时间正序→过滤系统通知→拼原文→建纪要；可选继续生成纪要文案与文档',
+    capability: 'minute',
+    risk: 'high-risk-write',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            mt_id: { type: 'string', pattern: '^\\d+$', description: '会议 id（必填）' },
+            subject: { type: 'string', description: '纪要标题，默认「群聊纪要-<会议名>」' },
+            groupId: { type: 'string', description: '群 id；省略时取会议记录的 imchat_groupid' },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: '用户提供的会议材料（本地文件路径，可多个）：txt/md/csv/json/docx/xlsx/pptx 会抽成文本一并写进纪要。'
+                    + '**只要会议有 imchat_groupid，群聊也会自动并入**，两者不冲突',
+            },
+            content: { type: 'string', description: '用户直接给的纪要正文/要点（与 files 可同时给），同样并入纪要' },
+            num: { type: 'integer', minimum: 1, maximum: 50, description: '拉取条数上限（默认 50）' },
+            from: {
+                type: 'string',
+                description: '起始时间；省略时取「会议创建时间 与 会议开始前 7 天 的较晚者」（会前在群里分工的那几天要覆盖到）',
+            },
+            to: { type: 'string', description: '结束时间；省略时取「当前时间 与 会议结束后 2 小时 的较早者」' },
+            sampling: {
+                type: 'boolean',
+                description: '消息超过 sampleThreshold 时是否采样去噪（默认 true）。关掉会把全部消息塞进原文，几千条时极慢且会撑爆 AI',
+            },
+            sampleThreshold: {
+                type: 'integer',
+                minimum: 10,
+                description: '触发采样的消息条数阈值（默认 200）',
+            },
+            perSenderLimit: {
+                type: 'integer',
+                minimum: 5,
+                description: '采样时每人最多保留多少条非关键消息（默认 60），防止刷屏者淹没别人',
+            },
+            digest: {
+                type: 'boolean',
+                description: '原文超过 maxTranscriptChars 时是否改用摘要版（默认 true）。摘要版只保留分工/结论/待办，'
+                    + '完整原文另存文件；设为 false 会硬塞全文，几万字时 ESB 生成纪要大概率失败',
+            },
+            maxTranscriptChars: {
+                type: 'integer',
+                minimum: 2000,
+                description: '原文长度上限（默认 20000 字）。超过则触发摘要版，避免把超长文本喂给 ESB',
+            },
+            keepSystem: {
+                type: 'boolean',
+                description: '是否保留系统通知（typeName=通知，如入群/改名）。默认 false 过滤掉，但会告知忽略了几条',
+            },
+            pipeline: {
+                type: 'string',
+                enum: ['text', 'minutes', 'document'],
+                description: 'text=只拼原文写进纪要（默认，最快）；minutes=继续调 ESB 生成纪要文案；document=再生成文档上传 OA',
+            },
+            employeeId: { type: 'string', description: 'ESB 触发人 id，省略时用当前登录人' },
+            aiPageId: {
+                type: 'string',
+                description: '智能纪要页面 id（mt_minutes_ai_page）。省略时从该会议已有纪要反查',
+            },
+            flowGenerateMinutes: {
+                type: 'string',
+                pattern: '^\\d+$',
+                description: 'ESB「根据解析文本生成智能纪要文本」流程 id。省略时用内置默认值；**换租户必须覆盖**'
+                    + '（流程 id 是租户级配置，各环境不同）',
+            },
+            flowGenerateDocument: {
+                type: 'string',
+                pattern: '^\\d+$',
+                description: 'ESB「保存解析并生成文档」流程 id。省略时用内置默认值；换租户必须覆盖',
+            },
+        },
+        required: ['mt_id'],
+    },
+    handler: async (args, env) => {
+        const startedAt = Date.now();
+        const timings = {};
+        const warnings = [];
+        const mark = (label, from) => {
+            timings[label] = Date.now() - from;
+        };
+        const mtId = textOf(args.mt_id).trim();
+        if (!mtId)
+            throw meetingValidationError('mt_id_required', '必须提供会议 id（mt_id）');
+        const pipeline = ['text', 'minutes', 'document'].includes(args.pipeline)
+            ? args.pipeline
+            : 'text';
+        const { getMeetingOperation } = await import('./registry.js');
+        const ctx = env.ctx;
+        // ① 会议 → 群 id
+        let stepStart = Date.now();
+        const listed = await getMeetingOperation('meeting.eb.meeting.list').handler({ mt_id: mtId, pageNo: 1, pageSize: 1 }, env);
+        const meeting = (listed?.data?.rows ?? [])[0]?.mainTable ?? null;
+        if (!meeting) {
+            throw meetingValidationError('not_found', `未找到会议 id=${mtId}，或当前账号无权限查看`, { id: mtId });
+        }
+        const groupId = textOf(args.groupId).trim() || textOf(meeting.imchat_groupid).trim();
+        const extraFiles = Array.isArray(args.files)
+            ? args.files.map((item) => textOf(item).trim()).filter((item) => item !== '')
+            : [];
+        const extraContent = textOf(args.content).trim();
+        const hasExtraSource = extraFiles.length > 0 || extraContent !== '';
+        if (!groupId && !hasExtraSource) {
+            throw meetingValidationError('group_missing', `会议「${textOf(meeting.mt_name)}」没有 imchat_groupid，也没有提供会议材料（files/content），无法生成纪要`, { id: mtId });
+        }
+        mark('readMeeting', stepStart);
+        // ② 拉群消息（走 im 模块，复用其翻页/区间逻辑）
+        const pullStart = Date.now();
+        const { createImHost } = await import('../../im/host.js');
+        const { createImContinuationSigner } = await import('../../im/continuation.js');
+        const { getImOperation } = await import('../../im/operations/registry.js');
+        const imEnv = { ctx, host: createImHost(ctx), continuation: createImContinuationSigner(ctx) };
+        const syncOp = getImOperation('im.msg.sync.group');
+        const chatWindow = computeChatWindow(meeting);
+        const defaultFrom = chatWindow.from;
+        const defaultTo = chatWindow.to;
+        // 有群才拉；只给材料（files/content）时不拉群，直接走合并
+        const pulled = groupId
+            ? await syncOp.handler({
+                groupId,
+                num: typeof args.num === 'number' ? args.num : 50,
+                from: args.from ? String(args.from) : defaultFrom,
+                to: args.to ? String(args.to) : defaultTo,
+            }, imEnv)
+            : { data: { messages: [] } };
+        const messages = pulled?.data?.messages ?? [];
+        mark('pullMessages', pullStart);
+        if (messages.length === 0 && !hasExtraSource) {
+            return meetingSuccess('meeting.minute.fromGroupChat', { id: mtId, groupId, messageCount: 0, minuteId: null, timings }, { warnings: ['该群在指定时间范围内没有消息，且未提供会议材料，未建纪要'] });
+        }
+        if (messages.length === 0 && hasExtraSource) {
+            warnings.push('群聊在指定时间窗内没有消息，本次仅使用用户提供的会议材料生成纪要');
+        }
+        // ③ 说话人真名（sender='我' 时尤其需要）
+        stepStart = Date.now();
+        const uids = [...new Set(messages.map((m) => textOf(m.from_uid)).filter(Boolean))];
+        const nameByUid = {};
+        if (uids.length > 0) {
+            try {
+                const resolveOp = getImOperation('im.person.resolveByIds');
+                const resolved = await resolveOp.handler({ ids: uids }, imEnv);
+                for (const person of resolved?.data?.employees ?? []) {
+                    if (person?.uid && person?.name)
+                        nameByUid[String(person.uid)] = String(person.name);
+                }
+            }
+            catch (error) {
+                warnings.push(`说话人姓名解析失败，已回退为原始 sender：${String(error?.message ?? error).slice(0, 80)}`);
+            }
+        }
+        mark('resolveSenders', stepStart);
+        // ④ 重排 + （必要时采样）+ 过滤 + 拼原文
+        const keepSystem = args.keepSystem === true;
+        const sorted = [...messages].sort((a, b) => Number(a.msgtime ?? 0) - Number(b.msgtime ?? 0));
+        const threshold = typeof args.sampleThreshold === 'number' && args.sampleThreshold > 0 ? args.sampleThreshold : 200;
+        const perSenderLimit = typeof args.perSenderLimit === 'number' && args.perSenderLimit > 0 ? args.perSenderLimit : 60;
+        const sampling = args.sampling !== false;
+        let workMessages = sorted;
+        let sampledDropped = 0;
+        const sampled = sampling && sorted.length > threshold;
+        if (sampled) {
+            const result = sampleMessages(sorted, perSenderLimit);
+            workMessages = result.kept;
+            sampledDropped = result.dropped;
+            warnings.push(`消息 ${sorted.length} 条超过阈值 ${threshold}，已采样：采样阶段保留 ${result.kept.length} 条、丢弃 ${result.dropped} 条灌水/重复。`
+                + '需要全量请调大 sampleThreshold，或收窄 from/to 时间窗');
+        }
+        const { transcript: groupTranscript, kept: fullKept, ignoredSystem } = composeTranscript(workMessages, nameByUid, keepSystem);
+        // 用户提供的材料（文件/正文）也要进纪要 —— 与群聊**合并**而不是二选一。
+        // 口径：会议有 imchat_groupid 时群聊自动并入；用户再给材料就一起进。
+        const extraSections = [];
+        for (const file of extraFiles) {
+            try {
+                const { readFile } = await import('node:fs/promises');
+                const buffer = await readFile(file);
+                const { extractText } = await import('./attachment-content.js');
+                const extracted = extractText(buffer, file, '');
+                if (extracted.text.trim()) {
+                    extraSections.push(`【材料：${file.split(/[\\/]/).pop() ?? file}】\n${extracted.text.trim()}`);
+                }
+                else {
+                    warnings.push(`材料 ${file} 无法抽取文本（${extracted.kind}），已跳过`);
+                }
+            }
+            catch (error) {
+                warnings.push(`材料 ${file} 读取失败：${String(error?.message ?? error).slice(0, 80)}`);
+            }
+        }
+        if (extraContent)
+            extraSections.push(`【材料：用户提供的纪要正文】\n${extraContent}`);
+        const extraTranscript = extraSections.join('\n\n');
+        const fullTranscript = [
+            extraTranscript ? `===== 用户提供的会议材料 =====\n${extraTranscript}` : '',
+            groupTranscript ? `===== 群聊记录（${workMessages.length} 条）=====\n${groupTranscript}` : '',
+        ].filter(Boolean).join('\n\n');
+        if (ignoredSystem > 0)
+            warnings.push(`已忽略 ${ignoredSystem} 条系统通知（入群/改名等）；需要保留请传 keepSystem=true`);
+        if (!fullTranscript.trim()) {
+            return meetingSuccess('meeting.minute.fromGroupChat', { id: mtId, groupId, messageCount: messages.length, ignoredSystem, minuteId: null, timings }, { warnings: ['过滤系统消息后没有可用的文字内容，未建纪要'] });
+        }
+        // ④b 超长保护：采样后仍超上限 → 摘要版（方案 B）
+        // ESB 633 会把 minutes_content 整段喂给模型，几十万字不是慢而是会失败。
+        const maxChars = typeof args.maxTranscriptChars === 'number' && args.maxTranscriptChars > 0 ? args.maxTranscriptChars : 20_000;
+        let transcript = fullTranscript;
+        let kept = fullKept;
+        let digestMode = false;
+        let digestDropped = 0;
+        let digestTruncated = false;
+        let fullTranscriptPath = null;
+        if (fullTranscript.length > maxChars) {
+            if (args.digest === false) {
+                warnings.push(`原文 ${fullTranscript.length} 字超过上限 ${maxChars}，但已显式关闭摘要版（digest=false）：`
+                    + 'ESB 生成纪要很可能失败，建议收窄 from/to 时间窗或分批处理');
+            }
+            else {
+                const digest = buildDigest(workMessages, nameByUid, keepSystem, maxChars);
+                transcript = digest.transcript;
+                kept = digest.kept;
+                digestDropped = digest.dropped;
+                digestTruncated = digest.truncated;
+                digestMode = true;
+                try {
+                    fullTranscriptPath = await saveTranscript(ctx, mtId, fullTranscript);
+                }
+                catch (error) {
+                    warnings.push(`完整原文落盘失败：${String(error?.message ?? error).slice(0, 80)}`);
+                }
+                warnings.push(`原文 ${fullTranscript.length} 字超过上限 ${maxChars}，已改用**摘要版**：`
+                    + `只保留分工/结论/待办相关发言 ${digest.kept} 条（省略 ${digest.dropped} 条闲聊`
+                    + `${digest.truncated ? '，摘要本身仍超长已按时间截断' : ''}）。`
+                    + (fullTranscriptPath ? `完整原文已存到 ${fullTranscriptPath}。` : '')
+                    + '据此生成的纪要是摘要口径，与逐字全文有差异。');
+            }
+        }
+        // ⑤ 智能纪要页面 id（租户级常量，能反查就反查）
+        let aiPageId = textOf(args.aiPageId).trim();
+        if (!aiPageId) {
+            try {
+                const minuteList = await getMeetingOperation('meeting.eb.minute.list').handler({ mt_id: mtId, pageNo: 1, pageSize: 20 }, env);
+                const withPage = (minuteList?.data?.rows ?? [])
+                    .map((row) => row.mainTable ?? row)
+                    .find((row) => textOf(row?.mt_minutes_ai_page).trim());
+                if (withPage)
+                    aiPageId = textOf(withPage.mt_minutes_ai_page).trim();
+            }
+            catch {
+                // 反查失败不影响主流程
+            }
+            if (!aiPageId) {
+                warnings.push('未取到 mt_minutes_ai_page（可传 aiPageId）；ESB 解析该字段可能必填，缺它会失败');
+            }
+        }
+        // ⑥ 建纪要并写原文
+        stepStart = Date.now();
+        const subject = textOf(args.subject).trim() || `群聊纪要-${textOf(meeting.mt_name)}`;
+        const prepared = await getMeetingOperation('meeting.eb.minute.create.prepare').handler({
+            mt_id: mtId,
+            mt_minutes_subject: subject,
+            minutes_content: transcript,
+            minutes_status: '4',
+            ...(aiPageId ? { mt_minutes_ai_page: aiPageId } : {}),
+            ...(meeting.begin_datetime ? { begin_datetime: textOf(meeting.begin_datetime) } : {}),
+            ...(meeting.end_datetime ? { end_datetime: textOf(meeting.end_datetime) } : {}),
+        }, env);
+        const applied = await getMeetingOperation('meeting.eb.minute.create.apply').handler({ confirm: true, continuation: prepared?.data?.continuation }, env);
+        const minuteId = textOf((applied?.data?.dataIds ?? [])[0]);
+        if (!minuteId) {
+            throw meetingValidationError('minute_create_failed', '纪要创建未返回 id', { applied: applied?.data ?? null });
+        }
+        mark('createMinute', stepStart);
+        const result = {
+            id: mtId,
+            groupId,
+            minuteId,
+            subject,
+            messageCount: messages.length,
+            keptMessages: kept,
+            ignoredSystem,
+            sampled,
+            sampledDropped,
+            digestMode,
+            digestDropped,
+            digestTruncated,
+            fullTranscriptPath,
+            transcriptLength: transcript.length,
+            fullTranscriptLength: fullTranscript.length,
+            pipeline,
+            aiPageId: aiPageId || null,
+        };
+        if (pipeline === 'text') {
+            result.timings = { ...timings, total: Date.now() - startedAt };
+            return meetingSuccess('meeting.minute.fromGroupChat', result, warnings.length > 0 ? { warnings } : undefined);
+        }
+        // ⑦ 可选：ESB 633 生成纪要文案 / 628 生成文档
+        stepStart = Date.now();
+        const session = await env.host.getSession();
+        const employeeId = textOf(args.employeeId).trim() || textOf(session?.userId);
+        // 流程 id 是租户级配置：优先用入参覆盖，否则用内置默认值（参考租户）
+        const flowMinutes = textOf(args.flowGenerateMinutes).trim() || FLOW_GENERATE_MINUTES;
+        const flowDocument = textOf(args.flowGenerateDocument).trim() || FLOW_GENERATE_DOCUMENT;
+        if (!employeeId) {
+            warnings.push('未取到 ESB 触发人 id（employeeId），已跳过后续 ESB 调用');
+        }
+        else {
+            const { createEsbHost } = await import('../../esb/host.js');
+            const { createEsbContinuationSigner } = await import('../../esb/continuation.js');
+            const { getEsbOperation } = await import('../../esb/operations/registry.js');
+            const esbEnv = { ctx, host: createEsbHost(ctx), continuation: createEsbContinuationSigner(ctx) };
+            const prepareOp = getEsbOperation('esb.trigger.prepare');
+            const applyOp = getEsbOperation('esb.trigger.apply');
+            const trigger = async (flowId, mainTable) => {
+                const pre = await prepareOp.handler({ employeeId, esbFlowId: flowId, customParams: { mainTable } }, esbEnv);
+                return applyOp.handler({ continuation: pre?.data?.continuation, confirm: true }, esbEnv);
+            };
+            try {
+                await trigger(flowMinutes, { minuteId });
+                mark('esbMinuteText', stepStart);
+            }
+            catch (error) {
+                // ESB 是同步阻塞的，超时 ≠ 没执行；如实记录，稍后以回读结果为准
+                warnings.push(`ESB 生成纪要文案未正常返回（${String(error?.message ?? error).slice(0, 100)}）；已按回读结果继续`);
+            }
+            if (pipeline === 'document') {
+                const stepDocStart = Date.now();
+                const detail = await getMeetingOperation('meeting.eb.minute.detail').handler({ id: minuteId }, env);
+                const parseContent = textOf(detail?.data?.data?.parse_content);
+                if (!parseContent.trim()) {
+                    warnings.push('纪要文案为空，已跳过生成文档（文本生成可能仍在后台进行，可稍后用 meeting.minute.parseStatus 复查）');
+                }
+                else {
+                    try {
+                        await trigger(flowDocument, { parse_content: parseContent, mt_minute_id: minuteId });
+                        mark('esbDocument', stepDocStart);
+                    }
+                    catch (error) {
+                        warnings.push(`ESB 生成文档未正常返回（${String(error?.message ?? error).slice(0, 100)}）`);
+                    }
+                }
+            }
+        }
+        // ⑧ 回读最终状态（以服务端为准）
+        const final = await getMeetingOperation('meeting.eb.minute.detail').handler({ id: minuteId }, env);
+        const row = final?.data?.data ?? {};
+        result.finalStatus = textOf(row.minutes_status);
+        result.parseContentLength = textOf(row.parse_content).length;
+        result.documentId = textOf(row.mt_minutes) || null;
+        result.timings = { ...timings, total: Date.now() - startedAt };
+        return meetingSuccess('meeting.minute.fromGroupChat', result, warnings.length > 0 ? { warnings } : undefined);
+    },
+};
+export const meetingMinuteFromGroupChatOperations = [meetingMinuteFromGroupChat];