weaver-work-cli 0.1.21 → 0.1.23

package/dist/shortcuts/meeting/operations/eb/task-progress.js

@@ -0,0 +1,123 @@
+/**
+ * 决议任务的**进度汇总**（供 `meeting.eb.decisionTask.list` 声明式挂载，见 catalog 的 `summarizeRows`）。
+ *
+ * 为什么需要（2026-09-21/22 真机确立的口径，三个坑每次手算都容易踩）：
+ * 1. **任务主表的 `decision_status` 恒为「未完成」** —— 既不随明细变化，也无法经接口写入，
+ *    所以"任务完成了没"**只能**从 `detail1`（执行人跟进记录）读；
+ * 2. **`executors` 可能是单对象也可能是数组**（1 人 = 对象，多人 = 数组），直接取 length 会得到 undefined；
+ * 3. **`detail1` 只有"已跟进过"的人才有记录** —— 没跟进的执行人不在里面，
+ *    若按 detail1 统计人数会漏人（表现为"1/1 完成"，其实还有个人没跟进）。
+ *
+ * 故这里统一：**以 `executors` 为人员基准，用 `detail1` 覆盖其状态，缺失的人补 `pending`**。
+ * 状态归一化成英文枚举便于程序判断；中文展示交给调用方翻译。
+ */
+function toText(value) {
+    return value === undefined || value === null ? '' : String(value);
+}
+/**
+ * `finish_status` 归一化。
+ *
+ * EB 在不同接口/配置下可能回**中文渲染值**（已完成 / 已延期 / 未完成）或**数字 id**（0/1/2），
+ * 两种都兼容；无法识别的一律按 `pending`（宁可少报完成，不夸大）。
+ */
+function normalizeFinishStatus(raw) {
+    const text = toText(raw).trim();
+    if (text === '')
+        return 'pending';
+    if (text === '1' || text.includes('已完成') || text === '完成')
+        return 'done';
+    if (text === '2' || text.includes('延期'))
+        return 'overdue';
+    return 'pending';
+}
+/** 人员字段（`executors` / `executor`）兼容"单对象 | 数组 | 纯 id 串"，统一成 `[{id,name}]`。 */
+function toPeople(raw) {
+    const list = raw === undefined || raw === null ? [] : (Array.isArray(raw) ? raw : [raw]);
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        if (item === undefined || item === null)
+            continue;
+        if (typeof item === 'object') {
+            const id = toText(item.id).trim();
+            if (id === '' || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({ id, name: toText(item.name) });
+        }
+        else {
+            const id = toText(item).trim();
+            if (id === '' || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({ id, name: '' });
+        }
+    }
+    return out;
+}
+/** 单行 → 任务进度。 */
+function summarizeRow(row) {
+    const main = (row?.mainTable ?? row ?? {});
+    const mt = (main.mt_id ?? {});
+    // detail1：只有已跟进的人才有记录 ⇒ 先建索引，再按 executors 对齐（缺的补 pending）。
+    const followed = new Map();
+    const details = Array.isArray(row?.detail1) ? row.detail1 : [];
+    for (const item of details) {
+        const who = toPeople(item?.executor)[0];
+        if (!who)
+            continue;
+        followed.set(who.id, {
+            status: normalizeFinishStatus(item?.finish_status),
+            finishDate: toText(item?.finish_date),
+        });
+    }
+    const members = toPeople(main.executors).map((person) => {
+        const hit = followed.get(person.id);
+        return {
+            executorId: person.id,
+            executorName: person.name,
+            status: hit ? hit.status : 'pending',
+            finishDate: hit ? hit.finishDate : '',
+        };
+    });
+    // 兜底：主表没带 executors 时退化为按跟进记录统计，避免显示 0/0 让人误判"没有执行人"。
+    if (members.length === 0) {
+        for (const [id, hit] of followed) {
+            members.push({ executorId: id, executorName: '', status: hit.status, finishDate: hit.finishDate });
+        }
+    }
+    const done = members.filter((item) => item.status === 'done').length;
+    const overdue = members.filter((item) => item.status === 'overdue').length;
+    const pending = members.length - done - overdue;
+    const status = members.length === 0
+        ? 'pending'
+        : done === members.length
+            ? 'done'
+            : overdue > 0
+                ? 'overdue'
+                : done > 0
+                    ? 'inProgress'
+                    : 'pending';
+    return {
+        id: toText(main.id),
+        title: toText(main.decision_title),
+        mtId: toText(mt.id),
+        mtName: toText(mt.name),
+        plan: { begin: toText(main.begin_datetime), end: toText(main.end_datetime) },
+        progress: { total: members.length, done, overdue, pending, status, members },
+    };
+}
+/** `decisionTask.list` 的结果后处理：原始 `rows` 原样保留，这里只额外给出 `progress`。 */
+export function summarizeTaskProgress(rows) {
+    const items = rows.map((row) => summarizeRow(row ?? {}));
+    return {
+        summary: {
+            total: items.length,
+            done: items.filter((item) => item.progress.status === 'done').length,
+            overdue: items.filter((item) => item.progress.status === 'overdue').length,
+            inProgress: items.filter((item) => item.progress.status === 'inProgress').length,
+            pending: items.filter((item) => item.progress.status === 'pending').length,
+        },
+        items,
+    };
+}

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

@@ -16,6 +16,13 @@ function stateRoot(ctx) {
         return resolve(configured, '..');
     return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
 }
+/**
+ * 会议模块状态目录（`<stateRoot>/meeting`）：环境模式缓存、EB objid 缓存等落在这里。
+ * 导出供 link.ts 复用，避免各文件各自推导 stateRoot 导致缓存分裂。
+ */
+export function meetingStateDir(ctx) {
+    return resolve(stateRoot(ctx), 'meeting');
+}
 function cacheFile(ctx) {
     return resolve(stateRoot(ctx), 'meeting', 'env-mode.json');
 }
@@ -50,6 +57,74 @@ async function writeCache(ctx, baseUrl, mode, smokePath) {
         return `环境模式缓存写入失败（不影响本次结果，下次会重新冒烟）：${error instanceof Error ? error.message : String(error)}`;
     }
 }
+/**
+ * 解析当前环境的会议模式（EB / 标准版），供 `meeting.env.detect` 与 `meeting.link`
+ * 共用同一套缓存与冒烟逻辑（避免两处判定不一致导致链接模式选错）。
+ */
+export async function resolveMeetingEnvMode(host, ctx, options = {}) {
+    const session = await host.getSession();
+    // ① 默认先读缓存（按 baseUrl 固化）；refresh=true 才强制重新冒烟。
+    if (options.refresh !== true) {
+        const cache = await readCache(ctx);
+        const cached = cache.environments[session.baseUrl];
+        if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
+            return {
+                mode: cached.mode,
+                smokePath: cached.smokePath,
+                fromCache: true,
+                detectedAt: cached.detectedAt,
+            };
+        }
+    }
+    // ② 第 1 步：EB 版冒烟（EB 优先）。接口 404/业务失败均视为「EB 未配置」。
+    let ebError;
+    try {
+        await host.request({
+            method: 'POST',
+            path: EB_SMOKE_PATH,
+            operation: 'meeting.env.detect',
+            // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
+            // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
+            // 标准版（2026-09-20 真机复现）。
+            body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
+            // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
+            // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
+            acceptBusiness: ebBusinessSuccess,
+        });
+        const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
+        return { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false, warning };
+    }
+    catch (error) {
+        ebError = error;
+    }
+    // ③ 第 2 步：标准版冒烟（仅当 EB 冒烟未通过）。
+    try {
+        await host.request({
+            method: 'GET',
+            path: STD_CALENDAR_PATH,
+            operation: 'meeting.env.detect',
+        });
+        const ebDetail = ebError instanceof Error
+            ? `${ebError.type ?? 'api'}/${ebError.subtype ?? 'error'}: ${ebError.message}`
+            : String(ebError);
+        const warning = await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH);
+        return {
+            mode: 'standard',
+            smokePath: STD_CALENDAR_PATH,
+            fromCache: false,
+            ebSmokeFailed: true,
+            ebSmokeError: ebDetail,
+            warning,
+        };
+    }
+    catch (stdError) {
+        // 两步都不通 → 不写缓存，提示接口未配置完整。
+        throw meetingValidationError('env_unavailable', '当前环境 EB 版与标准版会议接口冒烟均未通过，请确认会议应用已安装且接口已配置完整', {
+            eb: ebError instanceof Error ? ebError.message : String(ebError),
+            standard: stdError instanceof Error ? stdError.message : String(stdError),
+        });
+    }
+}
 const meetingEnvDetect = {
     name: 'meeting.env.detect',
     resource: 'env',
@@ -67,67 +142,9 @@ const meetingEnvDetect = {
         },
     },
     handler: async (args, { host, ctx }) => {
-        const session = await host.getSession();
-        // ① 默认先读缓存（按 baseUrl 固化）；refresh=true 才强制重新冒烟。
-        if (args.refresh !== true) {
-            const cache = await readCache(ctx);
-            const cached = cache.environments[session.baseUrl];
-            if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
-                return meetingSuccess('meeting.env.detect', {
-                    mode: cached.mode,
-                    smokePath: cached.smokePath,
-                    fromCache: true,
-                    detectedAt: cached.detectedAt,
-                });
-            }
-        }
-        // ② 第 1 步：EB 版冒烟（EB 优先）。接口 404/业务失败均视为「EB 未配置」。
-        let ebError;
-        try {
-            await host.request({
-                method: 'POST',
-                path: EB_SMOKE_PATH,
-                operation: 'meeting.env.detect',
-                // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
-                // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
-                // 标准版（2026-09-20 真机复现）。
-                body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
-                // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
-                // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
-                acceptBusiness: ebBusinessSuccess,
-            });
-            const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
-            return meetingSuccess('meeting.env.detect', { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false }, warning ? { warnings: [warning] } : undefined);
-        }
-        catch (error) {
-            ebError = error;
-        }
-        // ③ 第 2 步：标准版冒烟（仅当 EB 冒烟未通过）。
-        try {
-            await host.request({
-                method: 'GET',
-                path: STD_CALENDAR_PATH,
-                operation: 'meeting.env.detect',
-            });
-            const ebDetail = ebError instanceof Error
-                ? `${ebError.type ?? 'api'}/${ebError.subtype ?? 'error'}: ${ebError.message}`
-                : String(ebError);
-            const warning = await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH);
-            return meetingSuccess('meeting.env.detect', {
-                mode: 'standard',
-                smokePath: STD_CALENDAR_PATH,
-                fromCache: false,
-                ebSmokeFailed: true,
-                ebSmokeError: ebDetail,
-            }, warning ? { warnings: [warning] } : undefined);
-        }
-        catch (stdError) {
-            // 两步都不通 → 不写缓存，提示接口未配置完整。
-            throw meetingValidationError('env_unavailable', '当前环境 EB 版与标准版会议接口冒烟均未通过，请确认会议应用已安装且接口已配置完整', {
-                eb: ebError instanceof Error ? ebError.message : String(ebError),
-                standard: stdError instanceof Error ? stdError.message : String(stdError),
-            });
-        }
+        const result = await resolveMeetingEnvMode(host, ctx, { refresh: args.refresh === true });
+        const { warning, ...data } = result;
+        return meetingSuccess('meeting.env.detect', data, warning ? { warnings: [warning] } : undefined);
     },
 };
 // ---------------------------------------------------------------------------

package/dist/shortcuts/meeting/operations/lifecycle.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 { assertMeetingExists, toIdString } from './shared.js';
+import { assertMeetingExists, mergeSnapshot, toIdString } from './shared.js';
 const CONTINUATION_TTL_SECONDS = 600;
 function fingerprint(value) {
     return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
@@ -84,14 +84,16 @@ function lifecyclePair(spec) {
             properties: {
                 confirm: { const: true },
                 continuation: { type: 'string', minLength: 1 },
-                id: { ...SCHEMA_ID, description: '会议 id（必须与 prepare 时一致）' },
+                id: { ...SCHEMA_ID, description: '会议 id（可选：省略时取 prepare 快照中的 id）' },
             },
-            required: ['confirm', 'continuation', 'id'],
+            required: ['confirm', 'continuation'],
         },
         handler: async (args, env) => {
             requireConfirm(args, applyName);
             const lease = await verifyLease(args, applyName, env);
-            const id = toIdString(args.id, 'id');
+            // 只传 confirm+continuation 时用 prepare 快照里的 id（与 create/change 的 apply 行为一致）。
+            const merged = mergeSnapshot(lease.payload, args);
+            const id = toIdString(merged.id, 'id');
             if (lease.fingerprint !== fingerprint({ id })) {
                 throw meetingValidationError('target_changed', '会议 id 与 prepare 时的快照不一致，请重新执行 prepare');
             }
@@ -129,11 +131,11 @@ export const meetingLifecycleOperations = [
     ...lifecyclePair({
         action: 'delete',
         resource: 'meeting',
-        summaryPrepare: '准备删除会议记录：回查会议存在性并生成确认预览，不写入（彻底删除）',
+        summaryPrepare: '准备删除会议记录：回查会议存在性并生成确认预览，不写入（软删：进回收站，可还原）',
         summaryApply: '提交删除会议记录（deleteMeetingDetail，源码为表单绑定，参数走 query）；必须在用户明确确认后调用',
         path: '/api/meeting/detail/deleteMeetingDetail',
         via: 'query',
         bodyOf: (id) => ({ id }),
-        note: '删除是彻底移除会议记录（区别于取消）；不可逆，需用户明确确认。服务端会按会议状态判定删除权限，无权限时返回“您没有删除权限！”。',
+        note: '删除是**软删**（服务端 update mt_detail set delete_type=2）：会议移入回收站、可从回收站还原，正常列表中不再出现；需要还原请引导用户到会议回收站页面操作（CLI 暂无还原能力）。服务端会按会议状态判定删除权限，无权限时返回“您没有删除权限！”。',
     }),
 ];

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

@@ -0,0 +1,125 @@
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess, schemaOf, SCHEMA_ID, SCHEMA_ID_LIST } from './types.js';
+import { resolveMeetingEnvMode } from './env.js';
+import { MEETING_EB_TAGS, STANDARD_NO_PAGE_TYPES, buildEbCardPath, buildStandardMeetingPath, meetingAbsoluteUrl, meetingMarkdownLink, resolveMeetingEbObjs, } from './eb/link.js';
+const EB_TYPES = Object.keys(MEETING_EB_TAGS);
+/**
+ * `meeting.link` —— 会议对象「打开链接」生成器（EB 版 + 标准版）。
+ *
+ * 为什么要单独一个 operation：链接地址随模式不同、且 EB 版需要按表 tag 动态解析 objid
+ * （objid 随环境变化、禁止硬编码，也不等于 formId），不能让 Agent 手工拼 URL。
+ * 解析失败只降级为「不附链接」并写 warnings，**不影响**主业务结果。
+ */
+const meetingLink = {
+    name: 'meeting.link',
+    resource: 'link',
+    method: 'resolve',
+    action: 'meeting.link',
+    summary: '生成对象详情页链接：EB 版 /sp/ebdfpage/card/0/{objid}/{dataid}（按 tag 解析 objid 并缓存）；标准版会议 /sp/meeting/meetingSingle?meetingId=（会议室/会议类型无单页，不附链接）',
+    capability: 'link',
+    risk: 'read',
+    inputSchema: schemaOf({
+        dataId: { ...SCHEMA_ID, description: '对象 id：标准版=会议 id；EB 版=表单数据 id（单条查询用）' },
+        dataIds: { ...SCHEMA_ID_LIST, description: '批量：一次为多条数据生成链接（列表输出用）' },
+        type: {
+            type: 'string',
+            enum: [...EB_TYPES],
+            description: '对象类别（默认 meeting）。映射 EB 表 tag，详见 references/meeting-eb.md 的链接章节',
+        },
+        tag: { type: 'string', description: '直接指定 EB 表 tag（如 uf_mt_detail），与 type 二选一，优先于 type' },
+        mode: {
+            type: 'string',
+            enum: ['auto', 'eb', 'standard'],
+            description: 'auto（默认）=按当前环境模式自动判定；也可显式指定',
+        },
+        name: { type: 'string', description: '链接显示名；传入后同时返回 markdown 内联链接' },
+        refresh: { type: 'boolean', description: 'true=强制重新解析 EB objid（忽略缓存）' },
+    }, { required: [] }),
+    handler: async (args, { host, ctx }) => {
+        const single = args.dataId !== undefined && args.dataId !== null && String(args.dataId).trim() !== '';
+        const batch = Array.isArray(args.dataIds)
+            ? args.dataIds.map((item) => String(item)).filter((item) => item.trim() !== '')
+            : [];
+        const dataIds = single ? [String(args.dataId)] : batch;
+        if (dataIds.length === 0) {
+            throw meetingValidationError('link_data_id_required', '生成链接必须提供 dataId（单条）或 dataIds（批量）');
+        }
+        const requestedType = args.type === undefined ? 'meeting' : String(args.type);
+        const tag = typeof args.tag === 'string' && args.tag.trim() !== ''
+            ? args.tag.trim()
+            : MEETING_EB_TAGS[requestedType];
+        if (!tag) {
+            throw meetingValidationError('link_type_invalid', `未知对象类别：${requestedType}（可用：${EB_TYPES.join(' / ')}，或用 tag 直接指定表 tag）`);
+        }
+        const session = await host.getSession();
+        const warnings = [];
+        const requestedMode = args.mode === undefined ? 'auto' : String(args.mode);
+        let mode;
+        if (requestedMode === 'eb' || requestedMode === 'standard') {
+            mode = requestedMode;
+        }
+        else {
+            const detected = await resolveMeetingEnvMode(host, ctx, {});
+            mode = detected.mode;
+            if (detected.warning)
+                warnings.push(detected.warning);
+        }
+        let objId = null;
+        let appId = null;
+        let fromCache = false;
+        if (mode === 'standard') {
+            // 标准版：只有会议详情有单页；会议室 / 会议类型明确无单页（standalone 口径）。
+            if (STANDARD_NO_PAGE_TYPES.includes(requestedType)) {
+                warnings.push(`标准版「${requestedType}」没有单页地址，按口径只输出数据、不附链接`);
+            }
+            else if (requestedType !== 'meeting') {
+                warnings.push(`标准版未记录「${requestedType}」的单页地址，已跳过链接生成`);
+            }
+        }
+        else {
+            const resolved = await resolveMeetingEbObjs(host, ctx, { tags: [tag], refresh: args.refresh === true });
+            objId = resolved.objs[tag]?.objId ?? null;
+            appId = resolved.appId;
+            fromCache = resolved.fromCache;
+            warnings.push(...resolved.warnings);
+            if (!objId)
+                warnings.push(`未解析到 tag=${tag} 的 objid，本次不附链接`);
+        }
+        const noStdPage = mode === 'standard' && requestedType !== 'meeting';
+        const items = dataIds.map((dataId) => {
+            const path = mode === 'eb'
+                ? (objId ? buildEbCardPath(objId, dataId) : null)
+                : (noStdPage ? null : buildStandardMeetingPath(dataId));
+            const url = meetingAbsoluteUrl(session.baseUrl, path);
+            const item = { dataId, path, url };
+            const markdown = typeof args.name === 'string' && args.name.trim() !== ''
+                ? meetingMarkdownLink(args.name, url)
+                : undefined;
+            if (markdown)
+                item.markdown = markdown;
+            return item;
+        });
+        // source：objid 的来源（cache/dynamic）；标准版不需要 objid ⇒ none。
+        const source = mode === 'eb' ? (objId ? (fromCache ? 'cache' : 'dynamic') : 'none') : 'none';
+        const data = {
+            mode,
+            type: requestedType,
+            // 标准版不涉及 EB 表 tag，返回 null 避免误用。
+            tag: mode === 'eb' ? tag : null,
+            baseUrl: session.baseUrl,
+            appId,
+            objId,
+            source,
+            items,
+        };
+        if (single) {
+            const [first] = items;
+            data.path = first.path;
+            data.url = first.url;
+            if (first.markdown)
+                data.markdown = first.markdown;
+        }
+        return meetingSuccess('meeting.link', data, warnings.length ? { warnings } : {});
+    },
+};
+export const meetingLinkOperations = [meetingLink];

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { meetingPartialError, meetingValidationError } from '../errors.js';
 import { meetingSuccess, SCHEMA_ID } from './types.js';
-import { extractRows, toIdString } from './shared.js';
+import { extractRows, mergeSnapshot, pickBusinessInput, toIdString } from './shared.js';
 const CONTINUATION_TTL_SECONDS = 600;
 function fingerprint(value) {
     return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
@@ -30,7 +30,7 @@ const meetingReceiptList = {
     resource: 'receipt',
     method: 'receipt.list',
     action: 'meeting.receipt.list',
-    summary: '查询会议回执列表（getMeetingReceiptMemberInfoList；isMobile 缺省 false，缺失会导致后端 NPE）',
+    summary: '查询会议回执列表（getMeetingReceiptMemberInfoList；isMobile 缺省 false、memberType 缺省 1，二者缺失均会导致后端 NPE→500）',
     capability: 'receipt',
     risk: 'read',
     inputSchema: {
@@ -38,8 +38,8 @@ const meetingReceiptList = {
         additionalProperties: false,
         properties: {
             mtId: { ...SCHEMA_ID, description: '会议 id（必填）' },
-            memberType: { type: 'integer', enum: [1, 2, 3], description: '人员类型：1=人员 2=客户 3=其他（默认 1）' },
-            isMobile: { type: 'boolean', description: '移动端标记（默认 false）' },
+            memberType: { type: 'integer', enum: [1, 2, 3], description: '人员类型：1=人员 2=客户 3=其他（默认 1，**不传会导致后端 500**）' },
+            isMobile: { type: 'boolean', description: '移动端标记（默认 false，缺失会导致后端 NPE→500）' },
             current: { type: 'integer' },
             pageSize: { type: 'integer' },
         },
@@ -49,11 +49,12 @@ const meetingReceiptList = {
         const body = {
             mtId: toIdString(args.mtId, 'mtId'),
             isMobile: args.isMobile === undefined ? false : args.isMobile === true,
+            // 2026-10-08 真机实测（10.12.105.186）：**不传 memberType 必 500「系统内部错误」**，
+            // 传 1 即正常返回。历史文档只提醒了 isMobile，实际 memberType 同样不能缺省。
+            memberType: args.memberType === undefined ? 1 : args.memberType,
             current: typeof args.current === 'number' && args.current > 0 ? args.current : 1,
             pageSize: typeof args.pageSize === 'number' && args.pageSize > 0 ? args.pageSize : 50,
         };
-        if (args.memberType !== undefined)
-            body.memberType = args.memberType;
         const response = await host.request({
             method: 'POST',
             path: '/api/meeting/receiptMember/getMeetingReceiptMemberInfoList',
@@ -69,7 +70,9 @@ const meetingReceiptList = {
 // ---------------------------------------------------------------------------
 function normalizeReceiptUpdate(args) {
     const mtId = toIdString(args.mtId, 'mtId');
-    const memberId = toIdString(args.memberId, 'memberId');
+    // memberId 允许两种形态：人员 id（数字）或姓名文本 —— 列表返回的 `memberId` 字段其实是**姓名**
+    // （人员 id 在 `memberIdId`），若只接受数字会与列表结果自相矛盾（2026-10-08 真机实测）。
+    const memberId = toMemberSelector(args.memberId);
     const attendStatus = args.attendStatus;
     if (attendStatus !== 0 && attendStatus !== 1 && attendStatus !== 2) {
         throw meetingValidationError('attendStatus_invalid', 'attendStatus 仅允许 0=未填写 1=参加 2=不参加（回执"否"传 2）');
@@ -81,8 +84,24 @@ function normalizeReceiptUpdate(args) {
         ...(args.remark !== undefined ? { remark: String(args.remark) } : {}),
     };
 }
-/** 回查回执列表，按 memberId 定位回执记录 id（建会时后端自动生成，每参会人一条）。 */
-async function locateReceiptId(mtId, memberId, env) {
+/**
+ * 人员选择器：数字 → 人员 id；其它非空文本 → 姓名（用于按名字定位回执记录）。
+ * 列表返回里 `memberId` 是姓名、`memberIdId` 才是人员 id，故两种写法都要接受。
+ */
+function toMemberSelector(value) {
+    if (typeof value === 'number')
+        return toIdString(value, 'memberId');
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (/^\d+$/u.test(trimmed))
+            return trimmed;
+        if (trimmed)
+            return trimmed;
+    }
+    throw meetingValidationError('memberId_invalid', 'memberId 必须是人员 id（数字）或参会人姓名');
+}
+/** 回查回执列表，按人员 id / 姓名定位回执记录 id（建会时后端自动生成，每参会人一条）。 */
+async function locateReceipt(mtId, memberId, env) {
     const response = await env.host.request({
         method: 'POST',
         path: '/api/meeting/receiptMember/getMeetingReceiptMemberInfoList',
@@ -90,11 +109,20 @@ async function locateReceiptId(mtId, memberId, env) {
         body: { mtId, memberType: 1, isMobile: false, current: 1, pageSize: 100 },
     });
     const { rows } = extractRows(response);
-    const hit = rows.find((row) => String(row?.memberId) === memberId);
+    // ⚠️ 列表行的字段语义（2026-10-08 真机实测）：`memberId` = 姓名、`memberIdId` = 人员 id。
+    // 老实现只比对 `memberId`，传入真实人员 id 永远匹配不到 ⇒ 回执更新不可用。
+    const hit = rows.find((row) => {
+        const byId = String(row?.memberIdId ?? '') === memberId;
+        const byName = String(row?.memberId ?? '').trim() === memberId;
+        return byId || byName;
+    });
     if (!hit || hit.id === undefined) {
-        throw meetingValidationError('receipt_not_found', `未找到该参会人（memberId=${memberId}）的回执记录，请先通过 meeting.receipt.list 核对`);
+        throw meetingValidationError('receipt_not_found', `未找到该参会人（memberId=${memberId}）的回执记录，请先通过 meeting.receipt.list 核对（列表中 memberId 是姓名、memberIdId 是人员 id）`);
     }
-    return String(hit.id);
+    return {
+        receiptId: String(hit.id),
+        memberIdResolved: String(hit.memberIdId ?? hit.memberId ?? memberId),
+    };
 }
 const meetingReceiptUpdatePrepare = {
     name: 'meeting.receipt.update.prepare',
@@ -110,7 +138,7 @@ const meetingReceiptUpdatePrepare = {
         additionalProperties: false,
         properties: {
             mtId: { ...SCHEMA_ID, description: '会议 id' },
-            memberId: { ...SCHEMA_ID, description: '参会人员 id（用于定位回执记录）' },
+            memberId: { type: 'string', description: '参会人员 id 或姓名（用于定位回执记录；列表里 memberId 是姓名、memberIdId 才是人员 id，两者都接受）' },
             attendStatus: { type: 'integer', enum: [0, 1, 2], description: '0=未填写 1=参加 2=不参加' },
             remark: { type: 'string', description: '备注（如"请假"）' },
         },
@@ -118,9 +146,10 @@ const meetingReceiptUpdatePrepare = {
     },
     handler: async (args, env) => {
         const normalized = normalizeReceiptUpdate(args);
-        const receiptId = await locateReceiptId(String(normalized.mtId), String(normalized.memberId), env);
+        const located = await locateReceipt(String(normalized.mtId), String(normalized.memberId), env);
         const session = await env.host.getSession();
-        const payload = { id: receiptId, ...normalized };
+        // 写请求 body 统一带**解析后的人员 id**（列表里的 memberId 是姓名，直接回传姓名对服务端无意义）。
+        const payload = { id: located.receiptId, ...normalized, memberId: located.memberIdResolved };
         const token = await env.continuation.issue({
             operation: 'meeting.receipt.update.apply',
             baseUrl: session.baseUrl,
@@ -153,18 +182,22 @@ const meetingReceiptUpdateApply = {
             confirm: { const: true },
             continuation: { type: 'string', minLength: 1 },
             mtId: SCHEMA_ID,
-            memberId: SCHEMA_ID,
+            memberId: { type: 'string' },
             attendStatus: { type: 'integer', enum: [0, 1, 2] },
             remark: { type: 'string' },
         },
-        required: ['confirm', 'continuation', 'mtId', 'memberId', 'attendStatus'],
+        required: ['confirm', 'continuation'],
     },
     handler: async (args, env) => {
         requireConfirm(args, 'meeting.receipt.update.apply');
         const lease = await verifyLease(args, 'meeting.receipt.update.apply', env);
-        const normalized = normalizeReceiptUpdate(args);
-        if (lease.fingerprint !== fingerprint(normalized)) {
-            throw meetingValidationError('target_changed', '回执内容与 prepare 时的快照不一致，请重新执行 prepare');
+        // 只传 confirm+continuation 时直接用 prepare 快照；传了业务字段则与快照合并后校验一致性。
+        const business = pickBusinessInput(args);
+        if (Object.keys(business).length > 0) {
+            const normalized = normalizeReceiptUpdate(mergeSnapshot(lease.payload, args));
+            if (lease.fingerprint !== fingerprint(normalized)) {
+                throw meetingValidationError('target_changed', '回执内容与 prepare 时的快照不一致，请重新执行 prepare');
+            }
         }
         const payload = lease.payload;
         let response;
@@ -178,7 +211,7 @@ const meetingReceiptUpdateApply = {
         }
         catch (error) {
             if (isNetworkError(error)) {
-                throw meetingPartialError('回执更新请求发送后连接中断，是否已生效不确定，禁止自动重试，请通过 meeting.receipt.list 复核', { attempted: { mtId: normalized.mtId, memberId: normalized.memberId } }, { stage: 'receipt-update' });
+                throw meetingPartialError('回执更新请求发送后连接中断，是否已生效不确定，禁止自动重试，请通过 meeting.receipt.list 复核', { attempted: { mtId: payload.mtId, memberId: payload.memberId } }, { stage: 'receipt-update' });
             }
             throw error;
         }

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

@@ -9,6 +9,7 @@ import { meetingCreateOperations } from './create.js';
 import { meetingLifecycleOperations } from './lifecycle.js';
 import { meetingReceiptOperations } from './receipts.js';
 import { meetingSignOperations } from './signs.js';
+import { meetingLinkOperations } from './link.js';
 import { meetingEbOperations } from './eb/index.js';
 function buildRegistry() {
     const registry = new Map();
@@ -23,6 +24,7 @@ function buildRegistry() {
         ...meetingChangeOperations,
         ...meetingReceiptOperations,
         ...meetingSignOperations,
+        ...meetingLinkOperations,
         ...meetingEbOperations,
     ];
     for (const definition of definitions) {