weaver-work-cli 0.1.28 → 0.1.31

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

@@ -0,0 +1,276 @@
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess, schemaOf, SCHEMA_ID } from './types.js';
+import { computeChatWindow, composeTranscript, sampleMessages } from './from-group-chat.js';
+const ALL_SECTIONS = ['minutes', 'tasks', 'attachments', 'chat'];
+function textOf(value) {
+    return value === undefined || value === null ? '' : String(value);
+}
+function toRows(result) {
+    return Array.isArray(result?.data?.rows) ? result.data.rows : [];
+}
+function mainTableOf(row) {
+    return ((row?.mainTable ?? row ?? {}) ?? {});
+}
+function latestMinute(rows) {
+    if (rows.length === 0)
+        return null;
+    const scored = rows
+        .map((row) => ({ row, at: textOf(mainTableOf(row).update_time) || textOf(mainTableOf(row).create_time) }))
+        // 时间串是 `YYYY-MM-DD HH:mm:ss`，字典序即时间序；排不出就保持原顺序
+        .sort((a, b) => (a.at === b.at ? 0 : a.at < b.at ? 1 : -1));
+    return mainTableOf(scored[0].row);
+}
+const meetingSummaryGet = {
+    name: 'meeting.summary.get',
+    resource: 'summary',
+    method: 'get',
+    action: 'meeting.summary.get',
+    summary: '总结会议的材料聚合（只读、零副作用）：一次拉齐会议主表 + 纪要原文/结构化纪要 + 任务进度 + 附件正文 + 群聊原文，供智能体自己总结；哪一路取不到会在 warnings 里说明',
+    capability: 'summary',
+    risk: 'read',
+    inputSchema: schemaOf({
+        mt_id: { ...SCHEMA_ID, description: '会议 id（必填）' },
+        minuteId: {
+            ...SCHEMA_ID,
+            description: '指定纪要 id；省略时取该会议**最新**一条纪要',
+        },
+        groupId: { type: 'string', description: '群 id；省略时取会议 imchat_groupid' },
+        include: {
+            type: 'array',
+            items: { type: 'string', enum: ALL_SECTIONS },
+            description: '只要哪几路材料，默认四路全要',
+        },
+        withAttachmentText: {
+            type: 'boolean',
+            description: '是否抽取附件正文（默认 true）。只需清单时可传 false 省掉下载',
+        },
+        maxAttachmentChars: { type: 'number', description: '每个附件返回正文的最大字符数（默认 4000）' },
+        maxChatChars: { type: 'number', description: '群聊原文最大字符数（默认 20000）' },
+        chatFrom: { type: 'string', description: '群聊起始时间，覆盖默认窗口' },
+        chatTo: { type: 'string', description: '群聊结束时间，覆盖默认窗口' },
+        chatNum: { type: 'number', description: '群聊拉取条数（默认 50）' },
+        keepSystem: { type: 'boolean', description: '保留系统通知（入群/改名等），默认过滤' },
+        taskPageSize: { type: 'number', description: '任务分页大小（默认 50）' },
+    }, { required: ['mt_id'] }),
+    handler: async (args, env) => {
+        const mtId = textOf(args.mt_id).trim();
+        if (!mtId)
+            throw meetingValidationError('mt_id_required', '必须提供会议 id（mt_id）');
+        const ctx = env.ctx;
+        const { getMeetingOperation } = await import('./registry.js');
+        const warnings = [];
+        const timings = {};
+        const include = Array.isArray(args.include) && args.include.length > 0
+            ? args.include.filter((item) => ALL_SECTIONS.includes(item))
+            : ALL_SECTIONS;
+        const wants = (section) => include.includes(section);
+        // ① 会议主表（群 id 也从这里来）
+        let stepStart = Date.now();
+        const listed = await getMeetingOperation('meeting.eb.meeting.list').handler({ mt_id: mtId, pageNo: 1, pageSize: 1 }, env);
+        const meeting = mainTableOf(toRows(listed)[0]);
+        if (!meeting.mt_name && !meeting.id) {
+            throw meetingValidationError('not_found', `未找到会议 id=${mtId}，或当前账号无权限查看`, { id: mtId });
+        }
+        timings.readMeeting = Date.now() - stepStart;
+        const groupId = textOf(args.groupId).trim() || textOf(meeting.imchat_groupid).trim();
+        const overview = {
+            id: textOf(meeting.id) || mtId,
+            name: textOf(meeting.mt_name),
+            begin: textOf(meeting.begin_datetime),
+            end: textOf(meeting.end_datetime),
+            address: textOf(meeting.address),
+            topic: textOf(meeting.mt_desc),
+            creator: textOf(meeting.mt_creator),
+            status: textOf(meeting.mt_status),
+            groupId: groupId || null,
+        };
+        // ② 纪要
+        let minute = null;
+        if (wants('minutes')) {
+            stepStart = Date.now();
+            try {
+                let target = mainTableOf({});
+                const givenMinuteId = textOf(args.minuteId).trim();
+                if (givenMinuteId) {
+                    const detail = await getMeetingOperation('meeting.eb.minute.detail').handler({ id: givenMinuteId }, env);
+                    target = mainTableOf(detail?.data?.data ?? detail?.data);
+                    if (!textOf(target.id))
+                        throw new Error(`纪要 ${givenMinuteId} 读取为空`);
+                }
+                else {
+                    const minutes = await getMeetingOperation('meeting.eb.minute.list').handler({ mt_id: mtId, pageNo: 1, pageSize: 20 }, env);
+                    const rows = toRows(minutes);
+                    const latest = latestMinute(rows);
+                    if (!latest) {
+                        warnings.push('该会议还没有纪要（minutes 段为 null）');
+                    }
+                    else {
+                        const detail = await getMeetingOperation('meeting.eb.minute.detail').handler({ id: textOf(latest.id) }, env);
+                        target = mainTableOf(detail?.data?.data ?? detail?.data);
+                        // ⚠️ 列表有记录、详情却取空时必须说出来：否则 minute 静默变 null，
+                        // 智能体会以为"这场会没纪要"，而其实是我们没读出来。
+                        if (!textOf(target.id)) {
+                            warnings.push(`纪要 ${textOf(latest.id)} 详情读取为空，minutes 段为 null`);
+                        }
+                    }
+                }
+                if (textOf(target.id)) {
+                    minute = {
+                        id: textOf(target.id),
+                        subject: textOf(target.mt_minutes_subject),
+                        status: textOf(target.minutes_status),
+                        documentId: textOf(target.mt_minutes) || null,
+                        // 原文：群聊 + 用户材料合并后的全文（无群时只有材料）
+                        content: textOf(target.minutes_content),
+                        contentLength: textOf(target.minutes_content).length,
+                        // ESB 生成的结构化纪要（富文本），是总结时信息密度最高的一份
+                        parseContent: textOf(target.parse_content),
+                        parseContentLength: textOf(target.parse_content).length,
+                    };
+                }
+            }
+            catch (error) {
+                warnings.push(`纪要读取失败：${String(error?.message ?? error).slice(0, 120)}`);
+            }
+            timings.minutes = Date.now() - stepStart;
+        }
+        // ③ 任务情况
+        let tasks = null;
+        if (wants('tasks')) {
+            stepStart = Date.now();
+            try {
+                const result = await getMeetingOperation('meeting.eb.decisionTask.list').handler({ mt_id: mtId, pageNo: 1, pageSize: Number(args.taskPageSize) > 0 ? Number(args.taskPageSize) : 50 }, env);
+                const progress = result?.data?.progress ?? null;
+                tasks = {
+                    total: Number(result?.data?.total ?? 0),
+                    // progress.summary: total/done/overdue/inProgress/pending
+                    // progress.items[]: 每条任务 title + plan + 每个执行人的 finish_status
+                    progress,
+                };
+                if (Number(result?.data?.total ?? 0) === 0) {
+                    warnings.push('该会议还没有决议任务（tasks.total=0）');
+                }
+            }
+            catch (error) {
+                warnings.push(`任务读取失败：${String(error?.message ?? error).slice(0, 120)}`);
+            }
+            timings.tasks = Date.now() - stepStart;
+        }
+        // ④ 会议资料（附件）
+        let attachments = null;
+        if (wants('attachments')) {
+            stepStart = Date.now();
+            try {
+                const list = await getMeetingOperation('meeting.attachment.list').handler({ mtId }, env);
+                const items = Array.isArray(list?.data?.items) ? list.data.items : [];
+                const withText = args.withAttachmentText !== false;
+                let texts = [];
+                if (withText && items.length > 0) {
+                    try {
+                        const extracted = await getMeetingOperation('meeting.attachment.extract').handler({ mtId, maxChars: Number(args.maxAttachmentChars) > 0 ? Number(args.maxAttachmentChars) : 4000 }, env);
+                        texts = Array.isArray(extracted?.data?.items) ? extracted.data.items : [];
+                    }
+                    catch (error) {
+                        warnings.push(`附件正文抽取失败（清单仍可用）：${String(error?.message ?? error).slice(0, 120)}`);
+                    }
+                }
+                attachments = {
+                    count: items.length,
+                    items,
+                    texts,
+                };
+                if (items.length === 0)
+                    warnings.push('该会议没有附件');
+            }
+            catch (error) {
+                warnings.push(`附件清单读取失败：${String(error?.message ?? error).slice(0, 120)}`);
+            }
+            timings.attachments = Date.now() - stepStart;
+        }
+        // ⑤ 群聊（只读，复用 from-group-chat 的时间窗/真名/过滤/采样口径，但**不建纪要**）
+        let chat = null;
+        if (wants('chat')) {
+            stepStart = Date.now();
+            if (!groupId) {
+                warnings.push('该会议没有关联群聊（imchat_groupid 为空），chat 段为 null');
+            }
+            else {
+                try {
+                    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,
+                        // 测试环境靠 env.imHost 注入假实现，否则会真的打到线上群聊
+                        host: env.imHost ?? createImHost(ctx),
+                        continuation: createImContinuationSigner(ctx),
+                    };
+                    const window = computeChatWindow(meeting);
+                    const from = textOf(args.chatFrom).trim() || window.from;
+                    const to = textOf(args.chatTo).trim() || window.to;
+                    const pulled = await getImOperation('im.msg.sync.group').handler({ groupId, num: Number(args.chatNum) > 0 ? Number(args.chatNum) : 50, from, to }, imEnv);
+                    const messages = Array.isArray(pulled?.data?.messages) ? pulled.data.messages : [];
+                    // sender='我' 不是人名，用 from_uid 反查真名
+                    const nameByUid = {};
+                    const uids = [...new Set(messages.map((m) => textOf(m.from_uid)).filter(Boolean))];
+                    if (uids.length > 0) {
+                        try {
+                            const resolved = await getImOperation('im.person.resolveByIds').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)}`);
+                        }
+                    }
+                    const sorted = [...messages].sort((a, b) => Number(a.msgtime ?? 0) - Number(b.msgtime ?? 0));
+                    const threshold = 200;
+                    let workMessages = sorted;
+                    let sampledDropped = 0;
+                    if (sorted.length > threshold) {
+                        const sampled = sampleMessages(sorted, 60);
+                        workMessages = sampled.kept;
+                        sampledDropped = sampled.dropped;
+                        warnings.push(`群消息 ${sorted.length} 条超过阈值 ${threshold}，已采样去噪（保留 ${sampled.kept.length}、丢弃 ${sampledDropped}）；`
+                            + '需要全量请调大 chatNum 或收窄 chatFrom/chatTo');
+                    }
+                    const composed = composeTranscript(workMessages, nameByUid, args.keepSystem === true);
+                    let transcript = composed.transcript;
+                    const maxChars = Number(args.maxChatChars) > 0 ? Number(args.maxChatChars) : 20_000;
+                    let truncated = false;
+                    if (transcript.length > maxChars) {
+                        transcript = transcript.slice(0, maxChars);
+                        truncated = true;
+                        warnings.push(`群聊原文 ${composed.transcript.length} 字超过 maxChatChars=${maxChars}，已截断`);
+                    }
+                    if (composed.ignoredSystem > 0) {
+                        warnings.push(`已忽略 ${composed.ignoredSystem} 条系统通知（入群/改名等）；需要保留传 keepSystem=true`);
+                    }
+                    chat = {
+                        groupId,
+                        from,
+                        to,
+                        messageCount: messages.length,
+                        kept: composed.kept,
+                        ignoredSystem: composed.ignoredSystem,
+                        sampledDropped,
+                        truncated,
+                        transcript,
+                    };
+                    if (messages.length === 0) {
+                        warnings.push(`群聊在 ${from} ~ ${to} 窗口内没有消息（可放宽 chatFrom/chatTo）`);
+                    }
+                }
+                catch (error) {
+                    warnings.push(`群聊读取失败：${String(error?.message ?? error).slice(0, 120)}`);
+                }
+            }
+            timings.chat = Date.now() - stepStart;
+        }
+        timings.total = Object.values(timings).reduce((sum, value) => sum + value, 0);
+        return meetingSuccess('meeting.summary.get', { id: mtId, overview, minute, tasks, attachments, chat, include, timings }, warnings.length > 0 ? { warnings } : {});
+    },
+};
+export const meetingSummaryOperations = [meetingSummaryGet];

package/dist/shortcuts/meeting/operations/task-notify.js

@@ -0,0 +1,325 @@
+/**
+ * 把会议决议任务推送到会关联的群聊。
+ *
+ * 背景（2026-10-27 用户提出）：决议任务生成后，团队成员并不知道自己被派了活，
+ * 还得有人口头通知。这里把「会议 → 群 → 任务清单」这条通知链做进 CLI。
+ *
+ * 设计取舍：
+ * - **默认只预览、不发送**：往群里发消息对外可见且不可撤回（超时后），
+ *   所以不带 `confirm:true` 时只回预览文本，由调用方确认后再发。
+ * - 复用 `im.msg.send.group` 的 prepare/apply，不自己拼 IM 请求 ——
+ *   IM 侧的鉴权、文本转义、错误码都在那层处理过了。
+ * - 任务清单按「未完成优先」排序，已完成的可选择不发（`onlyPending` 默认 true），
+ *   否则一次会议攒到后期，群里天天重复收到一大堆已完成项。
+ */
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess } from './types.js';
+function textOf(value) {
+    return value === undefined || value === null ? '' : String(value);
+}
+/** 任务是否未完成（`decision_status` 是数组，id=0 表示未完成）。 */
+export function isPendingTask(task) {
+    const raw = task.decision_status;
+    const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+    if (list.length === 0)
+        return true;
+    return list.some((item) => textOf(item?.id) === '0' || textOf(item?.name) === '未完成');
+}
+/** 执行人姓名列表。 */
+export function executorNames(task) {
+    const raw = task.executors;
+    const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+    return list.map((item) => textOf(item?.name).trim()).filter(Boolean);
+}
+/**
+ * 拼群消息文本。抽成纯函数便于单测 —— 排序、截断、空执行人这几条都得有断言，
+ * 群消息发出去就收不回来了，不能靠"看着差不多"。
+ */
+export function formatTaskMessage(input) {
+    const onlyPending = input.onlyPending !== false;
+    const maxTasks = typeof input.maxTasks === 'number' && input.maxTasks > 0 ? input.maxTasks : 20;
+    const all = input.tasks.filter((task) => textOf(task.decision_title).trim());
+    const pending = all.filter(isPendingTask).length;
+    const selected = (onlyPending ? all.filter(isPendingTask) : all).sort((a, b) => {
+        // 未完成在前；同状态按计划开始时间正序（先到期的先看）
+        const pa = isPendingTask(a) ? 0 : 1;
+        const pb = isPendingTask(b) ? 0 : 1;
+        if (pa !== pb)
+            return pa - pb;
+        return textOf(a.begin_datetime).localeCompare(textOf(b.begin_datetime));
+    });
+    const listed = selected.slice(0, maxTasks);
+    const title = textOf(input.title).trim() || `【会议任务通知】${input.meetingName}`;
+    const lines = [title, ''];
+    const begin = textOf(input.begin).trim();
+    const end = textOf(input.end).trim();
+    if (begin || end) {
+        lines.push(`会议时间：${[begin, end].filter(Boolean).join(' ~ ')}`);
+    }
+    const progress = input.progress ?? {};
+    const totalText = typeof progress.total === 'number' ? progress.total : all.length;
+    const doneText = typeof progress.done === 'number' ? progress.done : all.length - pending;
+    lines.push(`任务进度：共 ${totalText} 项，已完成 ${doneText}，待办 ${Math.max(totalText - doneText, 0)}`);
+    lines.push('');
+    lines.push(selected.length === 0
+        ? '本次会议的任务已全部完成，无需跟进。'
+        : '各位，本次会议已明确以下任务，请按计划推进并在群内反馈进度：');
+    lines.push('');
+    listed.forEach((task, index) => {
+        lines.push(`${index + 1}. ${textOf(task.decision_title).trim()}`);
+        const people = executorNames(task);
+        const render = input.renderName ?? ((name) => name);
+        lines.push(`   负责人：${people.length > 0 ? people.map(render).join('、') : '未指派'}`);
+        const plan = [textOf(task.begin_datetime).trim(), textOf(task.end_datetime).trim()].filter(Boolean).join(' ~ ');
+        if (plan)
+            lines.push(`   计划：${plan}`);
+        if (!isPendingTask(task))
+            lines.push('   状态：已完成');
+    });
+    if (selected.length > listed.length) {
+        lines.push('');
+        lines.push(`…另有 ${selected.length - listed.length} 项未列出（可到会议详情查看）`);
+    }
+    lines.push('');
+    lines.push(textOf(input.footer).trim() || '（本消息由会议助手自动推送）');
+    return { text: lines.join('\n'), listed: listed.length, pending, total: totalText, selected: listed };
+}
+// ---------------------------------------------------------------------------
+// @ 到具体执行人（2026-10-27 真机摸清，用户客户端确认「蓝色可点」）
+//
+// E10 群消息的 @ 由两部分组成：
+//   txt 里的占位符   `…:@<uid>; …`        ← 不蓝就说明只有这个、没带 atUsers
+//   请求体 atUsers   `[{ cid, uid }]`     ← ⭐ 决定「是不是真 @」的字段
+// 服务端收到 atUsers 后会自己生成落库的 `dt[0].txt.aus`（带 cid/id/nm/ob/t）。
+//
+// 逐项实测（同一段文本，只改请求字段）：
+//   txt 里写 @姓名                   → 纯文本，不变蓝 ❌
+//   txt + aus + dt（自己拼 aus）      → aus 被丢掉，不变蓝 ❌
+//   txt + atUsers                    → aus 落库 1~N 条，蓝色可点 ✅（单人/双人都验过）
+//
+// 所以：**必须带 atUsers**，aus/dt 不用自己拼。
+// 由于 `im.msg.send.group` 只支持纯文本，会议模块直接调 IM 发送端点（im 模块只调用、不改）。
+// ---------------------------------------------------------------------------
+const GREETING = '各位，本次会议已明确以下任务，请按计划推进并在群内反馈进度：';
+/** 把任务执行人匹配成群成员（按姓名），返回能 @ 的人和匹配不到的人。 */
+export function matchMentions(tasks, members) {
+    const byName = new Map();
+    for (const member of members) {
+        if (member.name)
+            byName.set(member.name.trim(), member);
+    }
+    const matched = [];
+    const missing = [];
+    const seenUid = new Set();
+    const seenName = new Set();
+    for (const task of tasks) {
+        for (const name of executorNames(task)) {
+            const hit = byName.get(name.trim());
+            if (!hit) {
+                if (!seenName.has(name)) {
+                    seenName.add(name);
+                    missing.push(name);
+                }
+                continue;
+            }
+            if (seenUid.has(hit.uid))
+                continue;
+            seenUid.add(hit.uid);
+            matched.push(hit);
+        }
+    }
+    return { matched, missing };
+}
+/**
+ * 生成「@人」那一行（不含正文其它部分）：
+ * - display：`@王五 @张三 请关注以下任务`（预览给人看）
+ * - wire：`:@uid1; :@uid2; 请关注以下任务`（发送给服务端）
+ * - atUsers：决定"是不是真 @"的字段
+ */
+export function buildMentionLine(matched) {
+    if (matched.length === 0)
+        return { displayLine: '', wireLine: '', atUsers: [] };
+    return {
+        displayLine: `${matched.map((member) => `@${member.name}`).join(' ')} 请关注以下任务`,
+        wireLine: `${matched.map((member) => `:@${member.uid};`).join(' ')} 请关注以下任务`,
+        // ⚠️ 只传 cid + uid；服务端据此生成 aus，多传的字段会被丢掉
+        atUsers: matched.map((member) => ({ cid: member.cid, uid: member.uid })),
+    };
+}
+/** 把 @ 行插到「各位，…」那句之前；正文里没有那句时附在末尾，避免悄悄丢掉 @。 */
+export function insertMentionLine(text, line) {
+    if (!line)
+        return text;
+    if (text.includes(GREETING))
+        return text.replace(GREETING, `${line}\n\n${GREETING}`);
+    return `${text}\n${line}`;
+}
+const meetingDecisionNotifyGroup = {
+    name: 'meeting.decision.notifyGroup',
+    resource: 'decision',
+    method: 'notifyGroup',
+    action: 'meeting.decision.notifyGroup',
+    summary: '把会议的决议任务整理成通知推送到关联群聊：默认只预览不发送，带 confirm:true 才真正发出',
+    capability: 'decision',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            mt_id: { type: 'string', pattern: '^\\d+$', description: '会议 id（必填）' },
+            groupId: { type: 'string', description: '群 id；省略时取会议记录的 imchat_groupid' },
+            onlyPending: {
+                type: 'boolean',
+                description: '只推送未完成任务（默认 true）。设为 false 会把已完成项也列出来',
+            },
+            maxTasks: { type: 'integer', minimum: 1, maximum: 100, description: '消息里最多列多少条任务（默认 20）' },
+            title: { type: 'string', description: '消息标题，默认「【会议任务通知】<会议名>」' },
+            footer: { type: 'string', description: '消息末尾说明，默认「（本消息由会议助手自动推送）」' },
+            mention: {
+                type: 'boolean',
+                description: '是否 @ 到任务执行人（默认 true）。执行人必须是群成员才能 @ 上，否则只在正文里写名字',
+            },
+            confirm: {
+                type: 'boolean',
+                description: '真正发送需要显式传 true；不传只返回预览（群消息对外可见，发出去撤不回）',
+            },
+        },
+        required: ['mt_id'],
+    },
+    handler: async (args, env) => {
+        const startedAt = Date.now();
+        const warnings = [];
+        const mtId = textOf(args.mt_id).trim();
+        if (!mtId)
+            throw meetingValidationError('mt_id_required', '必须提供会议 id（mt_id）');
+        const { getMeetingOperation } = await import('./registry.js');
+        const ctx = env.ctx;
+        // ① 会议 → 群 + 展示信息
+        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();
+        if (!groupId) {
+            throw meetingValidationError('group_missing', `会议「${textOf(meeting.mt_name)}」没有 imchat_groupid，无法推送；请显式传 groupId`, { id: mtId });
+        }
+        // ② 决议任务
+        let taskList;
+        try {
+            taskList = await getMeetingOperation('meeting.eb.decisionTask.list').handler({ mt_id: mtId, pageNo: 1, pageSize: 100 }, env);
+        }
+        catch (error) {
+            throw meetingValidationError('task_list_failed', `读取决议任务失败：${String(error?.message ?? error).slice(0, 120)}`, { id: mtId });
+        }
+        // ⚠️ detail1 在 rows[] 顶层，mainTable 里没有 —— 这里两个都兜一下
+        const tasks = (taskList?.data?.rows ?? []).map((row) => ({
+            ...(row?.mainTable ?? {}),
+            ...row,
+        }));
+        if (tasks.length === 0) {
+            return meetingSuccess('meeting.decision.notifyGroup', { id: mtId, groupId, total: 0, sent: false, text: '' }, { warnings: ['该会议还没有决议任务，未推送（先调 meeting.eb.decision.publish 生成任务）'] });
+        }
+        const buildInput = {
+            meetingName: textOf(meeting.mt_name),
+            begin: textOf(meeting.begin_datetime),
+            end: textOf(meeting.end_datetime),
+            tasks,
+            progress: taskList?.data?.progress?.summary ?? undefined,
+            onlyPending: args.onlyPending !== false,
+            maxTasks: typeof args.maxTasks === 'number' ? args.maxTasks : 20,
+            title: textOf(args.title),
+            footer: textOf(args.footer),
+            meetingId: mtId,
+        };
+        const formatted = formatTaskMessage(buildInput);
+        const base = {
+            id: mtId,
+            groupId,
+            total: formatted.total,
+            pending: formatted.pending,
+            listed: formatted.listed,
+            charCount: formatted.text.length,
+            text: formatted.text,
+        };
+        // ②b @ 到执行人：先拿群成员表（uid + cid，atUsers 需要这两个）
+        const { createImHost } = await import('../../im/host.js');
+        const imHost = createImHost(ctx);
+        let displayText = formatted.text;
+        let wireText = formatted.text;
+        let atUsers = [];
+        const mentioned = [];
+        if (args.mention !== false) {
+            try {
+                const { getImOperation } = await import('../../im/operations/registry.js');
+                const membersResult = await getImOperation('im.group.users').handler({ groupId }, { ctx, host: imHost });
+                const members = (membersResult?.data?.members ?? []).map((item) => ({
+                    uid: textOf(item?.uid),
+                    cid: textOf(item?.cid),
+                    name: textOf(item?.name),
+                })).filter((item) => item.uid && item.name);
+                if (membersResult?.data?.endFlag === false) {
+                    warnings.push('群成员较多，只取到部分成员；未在返回里的执行人无法 @');
+                }
+                const { matched, missing } = matchMentions(formatted.selected, members);
+                // 「@ 人」既要有开头那一行，也要让每条任务的「负责人：」变成可点 @
+                const uidByName = new Map(matched.map((member) => [member.name.trim(), member.uid]));
+                const mentionLine = buildMentionLine(matched);
+                displayText = insertMentionLine(formatTaskMessage({ ...buildInput, renderName: (name) => (uidByName.has(name.trim()) ? `@${name}` : name) }).text, mentionLine.displayLine);
+                wireText = insertMentionLine(formatTaskMessage({
+                    ...buildInput,
+                    renderName: (name) => (uidByName.has(name.trim()) ? `:@${uidByName.get(name.trim())};` : name),
+                }).text, mentionLine.wireLine);
+                atUsers = mentionLine.atUsers;
+                mentioned.push(...matched.map((member) => member.name));
+                if (missing.length > 0) {
+                    warnings.push(`以下执行人不在群成员里（或姓名不一致），只能写在正文、无法 @：${missing.join('、')}`);
+                }
+            }
+            catch (error) {
+                warnings.push(`取群成员失败，本次不 @ 人：${String(error?.message ?? error).slice(0, 80)}`);
+            }
+        }
+        base.text = displayText;
+        base.charCount = displayText.length;
+        base.mentioned = mentioned;
+        // ③ 没确认就只回预览（群消息对外可见，默认不擅自发）
+        if (args.confirm !== true) {
+            return meetingSuccess('meeting.decision.notifyGroup', { ...base, sent: false, preview: true }, {
+                warnings: [
+                    '这是预览，**尚未发送**。确认内容无误后带 confirm:true 再调一次才会真正发到群里',
+                    `目标群：${groupId}`,
+                    ...(mentioned.length > 0
+                        ? [`将 @ ${mentioned.length} 人：${mentioned.join('、')}（发送时用 uid 占位符，预览显示为姓名）`]
+                        : []),
+                ],
+            });
+        }
+        // ④ 真正发送
+        // @ 必须靠请求体的 `atUsers`（服务端据此生成 dt[0].txt.aus 并渲染成蓝色可点），
+        // 自己拼 aus/dt 会被丢掉；所以这里直接调 IM 发送端点，而不是只支持纯文本的 `im.msg.send.group`。
+        let sent = false;
+        try {
+            const body = { groupId, txt: wireText };
+            if (atUsers.length > 0)
+                body.atUsers = atUsers;
+            const res = await imHost.request({
+                method: 'POST',
+                path: '/api/em/msg/executeIm/send/sendGroupMsg',
+                body,
+                operation: 'meeting.decision.notifyGroup',
+            });
+            const action = res?.data?.actionMsg ?? {};
+            if (Number(action.code) !== 0) {
+                throw new Error(`服务端拒绝：${textOf(action.message) || '未知原因'}`);
+            }
+            sent = true;
+        }
+        catch (error) {
+            throw meetingValidationError('send_failed', `发送群消息失败：${String(error?.message ?? error).slice(0, 160)}`, { id: mtId, groupId });
+        }
+        return meetingSuccess('meeting.decision.notifyGroup', { ...base, sent, preview: false, durationMs: Date.now() - startedAt }, warnings.length > 0 ? { warnings } : undefined);
+    },
+};
+export const meetingDecisionNotifyOperations = [meetingDecisionNotifyGroup];

package/dist/shortcuts/meeting/operations.js

@@ -1,5 +1,32 @@
+import { appendFile, mkdir } from 'node:fs/promises';
+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';
+/**
+ * 调用流水（best-effort）：每次 operation 追加一行 JSON 到 `<state>/meeting/logs/calls.jsonl`。
+ *
+ * 用途：用户反馈"建个会要很久"时，先看**到底调了几次、每次多久**，
+ * 而不是靠猜（是 CLI 慢，还是对话里多轮往返）。写入失败一律忽略，绝不影响业务。
+ */
+function recordCall(context, operation, startedAt, ok, errorType) {
+    try {
+        const file = join(meetingStateDir(context.ctx), 'logs', 'calls.jsonl');
+        const line = JSON.stringify({
+            at: new Date().toISOString(),
+            operation,
+            ms: Date.now() - startedAt,
+            ok,
+            ...(errorType ? { errorType } : {}),
+        });
+        void mkdir(dirname(file), { recursive: true })
+            .then(() => appendFile(file, `${line}\n`, 'utf8'))
+            .catch(() => undefined);
+    }
+    catch {
+        // 记日志失败不影响主流程
+    }
+}
 export async function executeMeetingOperation(operation, rawInput, context) {
     const definition = getMeetingOperation(operation);
     const input = asObject(rawInput);
@@ -14,6 +41,20 @@ export async function executeMeetingOperation(operation, rawInput, context) {
         getSession() {
             return context.host.getSession();
         },
+        // 二进制下载必须透传：漏掉它会让 meeting.attachment.download/extract 报"host 不支持下载"
+        // （包装 host 只挑两个方法时最容易被漏掉，2026-10-28 真机踩过）。
+        ...(context.host.download
+            ? { download: (request) => context.host.download(request) }
+            : {}),
     };
-    return definition.handler(input, { ...context, host });
+    const startedAt = Date.now();
+    try {
+        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'));
+        throw error;
+    }
 }