weaver-work-cli 0.1.20 → 0.1.22

package/dist/shortcuts/hrm/operations/resolve.js

@@ -0,0 +1,449 @@
+import { hrmValidationError } from '../errors.js';
+import { browserBaseBody, orgLink, } from './shared.js';
+import { READ, SCHEMA_ID, hrmSuccess, schemaOf, } from './types.js';
+const VIRTUAL_PATH = '/api/bs/hrm/companyVirtual/listCompanyVirtual';
+const ORG_DETAIL_PATH = '/api/bs/hrm/organization/getForm';
+const ORG_TYPES = ['department', 'subcompany'];
+const DEFAULT_MAX_CANDIDATES = 20;
+const MAX_CANDIDATES = 200;
+const MAX_SUGGESTIONS = 5;
+function text(value) {
+    return value === undefined || value === null ? '' : String(value).trim();
+}
+/** 名称匹配忽略大小写、全半角差异和多余空白。 */
+function normalizedName(value) {
+    return text(value).normalize('NFKC').replace(/\s+/gu, '').toLocaleLowerCase();
+}
+function normalizePath(value) {
+    return text(value)
+        .split(/[|/]+/u)
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join('/');
+}
+function idValue(value, field) {
+    const valueText = text(value);
+    if (!/^\d+$/u.test(valueText)) {
+        throw hrmValidationError('id_invalid', `${field} 必须是数字 ID`);
+    }
+    return valueText;
+}
+function maxCandidatesValue(value) {
+    if (value === undefined || value === null || value === '')
+        return DEFAULT_MAX_CANDIDATES;
+    const numeric = Number(value);
+    if (!Number.isInteger(numeric) || numeric < 1 || numeric > MAX_CANDIDATES) {
+        throw hrmValidationError('number_invalid', `maxCandidates 必须是 1~${MAX_CANDIDATES} 的整数`);
+    }
+    return numeric;
+}
+function uniqueById(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (!item.id || seen.has(item.id))
+            return false;
+        seen.add(item.id);
+        return true;
+    });
+}
+function readVirtuals(response) {
+    const root = response?.data;
+    const rows = Array.isArray(root) ? root : Array.isArray(root?.data) ? root.data : [];
+    return uniqueById(rows
+        .map((row) => ({
+        id: text(row?.id ?? row?.value),
+        name: text(row?.content ?? row?.name ?? row?.label),
+    }))
+        .filter((item) => item.id && item.name));
+}
+function levenshtein(left, right) {
+    const a = [...left];
+    const b = [...right];
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= a.length; row += 1) {
+        const current = [row];
+        for (let column = 1; column <= b.length; column += 1) {
+            current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + (a[row - 1] === b[column - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+function similarity(left, right) {
+    const a = normalizedName(left);
+    const b = normalizedName(right);
+    const longest = Math.max([...a].length, [...b].length);
+    return longest === 0 ? 1 : 1 - levenshtein(a, b) / longest;
+}
+function nearVirtuals(keyword, virtuals) {
+    return virtuals
+        .map((item) => ({ item, score: similarity(keyword, item.name) }))
+        .filter(({ score }) => score >= 0.6 && score < 1)
+        .sort((left, right) => right.score - left.score)
+        .map(({ item }) => item)
+        .slice(0, MAX_SUGGESTIONS);
+}
+function orgPath(row, type) {
+    const direct = type === 'department' ? row.supDepartment : row.supSubDepartment;
+    if (text(direct))
+        return normalizePath(direct);
+    const title = text(row.title);
+    const name = text(row.name);
+    if (title && name && title.startsWith(`${name}|`)) {
+        return normalizePath(title.slice(name.length + 1));
+    }
+    return '';
+}
+function fullOrg(row, type, baseUrl, virtual) {
+    const id = text(row.id);
+    const name = text(row.name);
+    const parentPath = orgPath(row, type);
+    const rawFullPath = normalizePath(row.fullPath);
+    const fullPath = rawFullPath || (parentPath ? `${parentPath}/${name}` : name);
+    const virtualName = parentPath.split('/')[0] || virtual.name;
+    const parentId = text(row.parent?.id ?? row.parent);
+    const subcompanyId = text(row.subcompanyid ?? row.subcompanyId);
+    const virtualId = text(row.virtualid ?? row.virtualId) || virtual.id;
+    return {
+        id,
+        name,
+        type: text(row.type) || type,
+        ...(text(row.code) ? { code: text(row.code) } : {}),
+        fullPath,
+        ...(parentPath ? { parentPath } : {}),
+        ...(parentId ? { parentId } : {}),
+        ...(subcompanyId ? { subcompanyId } : {}),
+        virtualId,
+        virtualName,
+        ...(row.status !== undefined ? { status: row.status } : {}),
+        link: orgLink(baseUrl, id),
+    };
+}
+function orgCandidate(row, type, baseUrl, virtual) {
+    const item = fullOrg(row, type, baseUrl, virtual);
+    return {
+        id: item.id,
+        name: item.name,
+        type: item.type,
+        fullPath: item.fullPath,
+        ...(item.code ? { code: item.code } : {}),
+        link: item.link,
+    };
+}
+function browsePath(type) {
+    return type === 'department'
+        ? '/api/hrm/common/browser/data/department'
+        : '/api/hrm/common/browser/data/subcompany';
+}
+async function browseOrg(host, type, virtualId, keyword, condition, pageSize) {
+    const response = await host.request({
+        method: 'POST',
+        path: browsePath(type),
+        body: {
+            ...browserBaseBody(),
+            virtualType: 'ALL',
+            cmd: 'list',
+            current: 1,
+            pageSize,
+            companyId: virtualId,
+            formDatas: {
+                name: [{
+                        nameCondition: {
+                            id: condition,
+                            content: condition === 'eq' ? '等于' : '包含',
+                            disabled: false,
+                        },
+                        name: keyword,
+                    }],
+            },
+            quickSearchDatas: {},
+            type: 'and',
+            stopDepartment: false,
+        },
+    });
+    const data = response?.data ?? {};
+    const rows = Array.isArray(data.data) ? data.data : [];
+    const reportedTotal = Number(data.total);
+    return {
+        type,
+        rows,
+        total: Number.isFinite(reportedTotal) ? reportedTotal : rows.length,
+    };
+}
+async function browseTypes(host, types, virtualId, keyword, condition, pageSize) {
+    return Promise.all(types.map((type) => browseOrg(host, type, virtualId, keyword, condition, pageSize)));
+}
+function exactRows(results, keyword) {
+    const normalized = normalizedName(keyword);
+    return results.map((result) => {
+        const rows = result.rows.filter((row) => normalizedName(row.name) === normalized);
+        return { ...result, rows, total: rows.length };
+    });
+}
+function totalMatches(results) {
+    return results.reduce((sum, result) => sum + Math.max(result.total, result.rows.length), 0);
+}
+function allRows(results) {
+    return results.flatMap((result) => result.rows.map((row) => ({ type: result.type, row })));
+}
+function resolvedFromMatches(results, explicitType) {
+    if (explicitType) {
+        const result = results[0];
+        const count = Math.max(result.total, result.rows.length);
+        return {
+            selected: count === 1 && result.rows[0] ? { type: result.type, row: result.rows[0] } : undefined,
+            alternatives: [],
+            ambiguous: count > 1,
+        };
+    }
+    const department = results.find((result) => result.type === 'department');
+    const subcompany = results.find((result) => result.type === 'subcompany');
+    const departmentCount = department ? Math.max(department.total, department.rows.length) : 0;
+    const subcompanyCount = subcompany ? Math.max(subcompany.total, subcompany.rows.length) : 0;
+    if (departmentCount === 1 && department?.rows[0]) {
+        return {
+            selected: { type: 'department', row: department.rows[0] },
+            alternatives: (subcompany?.rows ?? []).map((row) => ({ type: 'subcompany', row })),
+            ambiguous: false,
+        };
+    }
+    if (departmentCount > 1)
+        return { alternatives: [], ambiguous: true };
+    if (subcompanyCount === 1 && subcompany?.rows[0]) {
+        return { selected: { type: 'subcompany', row: subcompany.rows[0] }, alternatives: [], ambiguous: false };
+    }
+    return { alternatives: [], ambiguous: subcompanyCount > 1 };
+}
+function truncatedCandidates(results, maxCandidates, baseUrl, virtual) {
+    const candidateTotal = totalMatches(results);
+    const candidates = allRows(results)
+        .slice(0, maxCandidates)
+        .map(({ type, row }) => orgCandidate(row, type, baseUrl, virtual));
+    return {
+        candidates,
+        candidateTotal,
+        truncated: candidateTotal > candidates.length,
+    };
+}
+async function resolveOrgId(host, orgId, baseUrl, virtual) {
+    const response = await host.request({
+        method: 'GET',
+        path: ORG_DETAIL_PATH,
+        query: { id: orgId, readOnly: true, includeSub: true, quote: true, isMobile: false },
+        headers: { Referer: `${baseUrl}/sp/hrm/orgCard/${orgId}` },
+    });
+    const raw = response?.data?.data ?? {};
+    const type = raw.type === 'subcompany' ? 'subcompany' : 'department';
+    const parentName = Array.isArray(raw.parent) ? text(raw.parent[0]?.name) : '';
+    const subcompanyName = Array.isArray(raw.subcompany) ? text(raw.subcompany[0]?.name) : '';
+    const fullPath = normalizePath(raw.fullPath);
+    const pathParts = fullPath.split('/').filter(Boolean);
+    return {
+        id: text(raw.id) || orgId,
+        name: text(raw.name),
+        type,
+        ...(text(raw.code) ? { code: text(raw.code) } : {}),
+        ...(fullPath ? { fullPath } : {}),
+        ...(pathParts.length > 1 ? { parentPath: pathParts.slice(0, -1).join('/') } : {}),
+        ...(parentName ? { parentName } : {}),
+        ...(subcompanyName ? { subcompanyName } : {}),
+        virtualId: virtual.id,
+        virtualName: virtual.name,
+        ...(raw.status !== undefined ? { status: raw.status } : {}),
+        link: orgLink(baseUrl, orgId),
+    };
+}
+function relaxedKeywords(name) {
+    const characters = [...text(name)];
+    if (characters.length <= 2)
+        return [characters.join('')].filter(Boolean);
+    const suffix = characters.slice(-2).join('');
+    const prefix = characters.slice(0, 2).join('');
+    return suffix === prefix ? [suffix] : [suffix, prefix];
+}
+async function nearOrgSuggestions(host, type, virtual, name, pageSize, baseUrl) {
+    const results = [];
+    const seen = new Set();
+    for (const keyword of relaxedKeywords(name)) {
+        const result = await browseOrg(host, type, virtual.id, keyword, 'in', pageSize);
+        for (const row of result.rows) {
+            const id = text(row.id);
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            results.push(orgCandidate(row, type, baseUrl, virtual));
+        }
+    }
+    return results;
+}
+const orgResolve = {
+    name: 'hrm.org.resolve',
+    resource: 'org',
+    method: 'org.resolve',
+    action: 'hrm.org.resolve',
+    summary: '按多维名称与组织名称解析唯一部门/分部；歧义或近似名称只返回候选，不代替用户选择',
+    risk: READ,
+    inputSchema: schemaOf({
+        virtual: { type: 'string', minLength: 1, description: '多维名称；与 virtualId 至少传一个' },
+        virtualId: SCHEMA_ID,
+        name: { type: 'string', minLength: 1, description: '组织名称；与 orgId 至少传一个' },
+        orgId: SCHEMA_ID,
+        type: { type: 'string', enum: [...ORG_TYPES] },
+        maxCandidates: { type: 'integer', minimum: 1, maximum: MAX_CANDIDATES, default: DEFAULT_MAX_CANDIDATES },
+    }),
+    handler: async (args, { host }) => {
+        const virtualKeyword = text(args.virtual);
+        const name = text(args.name);
+        const virtualId = args.virtualId === undefined ? '' : idValue(args.virtualId, 'virtualId');
+        const orgId = args.orgId === undefined ? '' : idValue(args.orgId, 'orgId');
+        if (!virtualKeyword && !virtualId) {
+            throw hrmValidationError('virtual_required', 'virtual 或 virtualId 至少传一个');
+        }
+        if (!name && !orgId) {
+            throw hrmValidationError('name_required', 'name 或 orgId 至少传一个');
+        }
+        const explicitType = args.type !== undefined;
+        const requestedType = explicitType ? text(args.type) : '';
+        if (explicitType && !ORG_TYPES.includes(requestedType)) {
+            throw hrmValidationError('enum_invalid', `type 取值必须是 ${ORG_TYPES.join(' / ')} 之一`);
+        }
+        const types = explicitType
+            ? [requestedType]
+            : ['department', 'subcompany'];
+        const maxCandidates = maxCandidatesValue(args.maxCandidates);
+        const pageSize = Math.max(100, maxCandidates);
+        const virtualResponse = await host.request({ method: 'GET', path: VIRTUAL_PATH });
+        const virtuals = readVirtuals(virtualResponse);
+        let virtual;
+        let virtualMatchType = 'exact';
+        if (virtualId) {
+            virtual = virtuals.find((item) => item.id === virtualId);
+            virtualMatchType = 'id';
+        }
+        else {
+            const keyword = normalizedName(virtualKeyword);
+            const exact = virtuals.filter((item) => normalizedName(item.name) === keyword);
+            const matches = exact.length > 0
+                ? exact
+                : virtuals.filter((item) => normalizedName(item.name).includes(keyword));
+            virtualMatchType = exact.length > 0 ? 'exact' : 'fuzzy';
+            if (matches.length > 1) {
+                const candidates = matches.slice(0, maxCandidates);
+                return hrmSuccess('hrm.org.resolve', {
+                    status: 'ambiguous',
+                    stage: 'virtual',
+                    virtual: null,
+                    matchType: virtualMatchType,
+                    candidates,
+                    candidateTotal: matches.length,
+                    truncated: matches.length > candidates.length,
+                    message: `多维「${virtualKeyword}」匹配到 ${matches.length} 个候选，请确认后把候选 id 作为 virtualId 复调。`,
+                });
+            }
+            virtual = matches[0];
+        }
+        if (!virtual) {
+            const suggestions = virtualKeyword ? nearVirtuals(virtualKeyword, virtuals) : [];
+            const available = virtuals.map((item) => item.name).join('、');
+            const target = virtualId ? `ID ${virtualId}` : `「${virtualKeyword}」`;
+            const suggestionText = suggestions.length > 0
+                ? `；近似名称：${suggestions.map((item) => item.name).join('、')}。不要自行替换名称，请先让用户确认`
+                : '';
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'not_found',
+                stage: 'virtual',
+                virtual: null,
+                matchType: 'none',
+                candidates: [],
+                candidateTotal: 0,
+                suggestions,
+                suggestionTotal: suggestions.length,
+                availableVirtuals: virtuals,
+                message: `多维${target}不存在${suggestionText}。当前可用多维：${available || '无'}。`,
+            });
+        }
+        const virtualResult = {
+            id: virtual.id,
+            name: virtual.name,
+            keyword: virtualKeyword,
+            matchType: virtualMatchType,
+        };
+        const session = await host.getSession();
+        const baseUrl = session.baseUrl.replace(/\/+$/u, '');
+        if (orgId) {
+            const org = await resolveOrgId(host, orgId, baseUrl, virtual);
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'resolved',
+                stage: 'org',
+                matchType: 'id',
+                type: org.type,
+                virtual: virtualResult,
+                org,
+                message: `已按 orgId 定位组织「${String(org.name || orgId)}」。`,
+            });
+        }
+        let matchType = 'exact';
+        let matches = await browseTypes(host, types, virtual.id, name, 'eq', pageSize);
+        let choice = resolvedFromMatches(matches, explicitType);
+        if (!choice.selected && !choice.ambiguous) {
+            const fuzzyResults = await browseTypes(host, types, virtual.id, name, 'in', pageSize);
+            const normalizedExact = exactRows(fuzzyResults, name);
+            if (totalMatches(normalizedExact) > 0) {
+                matches = normalizedExact;
+                matchType = 'exact';
+            }
+            else {
+                matches = fuzzyResults;
+                matchType = 'fuzzy';
+            }
+            choice = resolvedFromMatches(matches, explicitType);
+        }
+        if (choice.selected) {
+            const org = fullOrg(choice.selected.row, choice.selected.type, baseUrl, virtual);
+            const alsoMatched = choice.alternatives.map(({ type, row }) => orgCandidate(row, type, baseUrl, virtual));
+            const fuzzyMessage = matchType === 'fuzzy' ? '（模糊匹配）' : '';
+            const alternativeMessage = alsoMatched.length > 0
+                ? `；另有同名节点 ${alsoMatched.length} 个，请一并告知用户`
+                : '';
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'resolved',
+                stage: 'org',
+                matchType,
+                type: choice.selected.type,
+                virtual: virtualResult,
+                org,
+                ...(alsoMatched.length > 0 ? { alsoMatched } : {}),
+                message: `已${fuzzyMessage}定位${choice.selected.type === 'department' ? '部门' : '分部'}「${name}」${alternativeMessage}。`,
+            });
+        }
+        if (choice.ambiguous) {
+            const candidateData = truncatedCandidates(matches, maxCandidates, baseUrl, virtual);
+            const truncatedMessage = candidateData.truncated ? `，仅列出前 ${maxCandidates} 个` : '';
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'ambiguous',
+                stage: 'org',
+                matchType,
+                virtual: virtualResult,
+                ...candidateData,
+                message: `组织「${name}」匹配到 ${candidateData.candidateTotal} 个候选${truncatedMessage}，请确认后把候选 id 作为 orgId 复调。`,
+            });
+        }
+        // 名称的精确/包含查询均未命中。近似探测只用于提示，绝不自动解析。
+        const suggestionType = (requestedType || 'department');
+        const allSuggestions = await nearOrgSuggestions(host, suggestionType, virtual, name, pageSize, baseUrl);
+        const suggestions = allSuggestions.slice(0, MAX_SUGGESTIONS);
+        const suggestionMessage = suggestions.length > 0
+            ? `；找到近似名称 ${suggestions.map((item) => item.name).join('、')}，不要自行替换名称，请先让用户确认`
+            : '';
+        return hrmSuccess('hrm.org.resolve', {
+            status: 'not_found',
+            stage: 'org',
+            matchType: 'none',
+            virtual: virtualResult,
+            suggestions,
+            suggestionTotal: allSuggestions.length,
+            message: `在多维「${virtual.name}」中未找到组织「${name}」${suggestionMessage}。`,
+        });
+    },
+};
+export const hrmResolveOperations = [orgResolve];

package/dist/shortcuts/invoice/host.js

@@ -135,10 +135,11 @@ export function createInvoiceHost(ctx, dependencies = {}) {
         if (typeof token !== 'string' || !token.trim()) {
             throw invoiceAuthError('invoice_token_missing', '未取得业票通业务 Token');
         }
-        const saved = await tokenStore.save(token);
-        if (!saved) {
-            throw invoiceAuthError('invoice_token_cache_failed', '发票 Token 安全缓存写入失败，已停止业务请求');
-        }
+        // Headless Web/Linux hosts may not provide a system keyring (for example,
+        // Secret Service over D-Bus). Persistence is only an optimization: keep
+        // the token in this process so the current business request can proceed,
+        // without falling back to an insecure plaintext cache.
+        await tokenStore.save(token);
         invoiceToken = token;
         return token;
     }

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

@@ -0,0 +1,151 @@
+/**
+ * EB 建会后的**关联数据补建**（占用 / 回执 / 签到）。
+ *
+ * 为什么必须补（2026-09-21 真机确认，应用设置 `open_mt_approve=0` + `only_flow_create=0`）：
+ * eBuilder 的**自定义接口** `create_meeting` 只写会议主表，**不会**像页面建会那样
+ * 自动生成占用视图 / 回执 / 签到记录；而这三样恰好是后续能力的硬依赖：
+ *
+ * - 没有**占用**（roomusage）⇒ 会议室冲突检测（`query_roomusage_list`）查不到这场会，
+ *   以后别人在同一时段订同一间会议室不会被拦住；
+ * - 没有**回执**（receipt）⇒ 参会人冲突检测（以回执表 member_id 为准）对本场会议失效；
+ * - 没有**签到**记录（sign）⇒ `meeting.eb.sign.mark`（补签）报「未找到签到记录」。
+ *
+ * 因此建会成功后由本模块按「会议 + 参会人」逐条补齐，语义与页面建会一致。
+ *
+ * 失败语义（重要）：主写入（建会）**已经成功**，这里任何一步失败都**不抛错**，
+ * 只把失败原因汇总进 `warnings` 并标明后果 —— 否则调用方会以为建会失败而重试，导致重复建会。
+ */
+import { EB_BASE, ebBusinessSuccess, normalizeEbWrite, writeBody } from './factory.js';
+import { EB_ENDPOINTS } from './catalog.js';
+/** 只在建会后补建关联数据；其他写操作直接跳过。 */
+const CREATE_MEETING_PK = 'create_meeting';
+/** 回执人员类型：1 = 参会人员（参会人冲突检测只统计该类型）。 */
+const MEMBER_TYPE_ATTENDEE = '1';
+function requireEndpoint(interfacePk) {
+    const endpoint = EB_ENDPOINTS.find((item) => item.interfacePk === interfacePk);
+    if (!endpoint)
+        throw new Error(`EB catalog 缺少 ${interfacePk}，请检查 catalog.ts 声明`);
+    return endpoint;
+}
+/** 逗号分隔 id 串（`hrm_members` 等）→ 去重去空后的数组。 */
+function splitIds(value) {
+    if (value === undefined || value === null)
+        return [];
+    const text = String(value).trim();
+    if (text === '')
+        return [];
+    const seen = new Set();
+    for (const part of text.split(',')) {
+        const id = part.trim();
+        if (id !== '')
+            seen.add(id);
+    }
+    return [...seen];
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * 单条 EB 写入。**不抛错**：返回失败原因交由调用方汇总（主写入已成功，不可中断）。
+ * 复用 `normalizeEbWrite` 以保证字段白名单 / 必填 / 日期格式与手动调用完全一致。
+ */
+async function writeOne(env, interfacePk, args) {
+    try {
+        const session = await env.host.getSession();
+        const payload = normalizeEbWrite(requireEndpoint(interfacePk), args, session.userId);
+        const response = await env.host.request({
+            method: 'POST',
+            path: `${EB_BASE}/saveFormData/${interfacePk}`,
+            operation: 'meeting.eb.meeting.create.apply',
+            body: writeBody(session.userId, payload),
+            acceptBusiness: ebBusinessSuccess,
+        });
+        if (response?.datajson?.status === false) {
+            return { ok: false, error: `${interfacePk} 返回 status=false` };
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, error: `${interfacePk}: ${errorText(error)}` };
+    }
+}
+export const ebMeetingAssociation = async (ctx) => {
+    if (ctx.endpoint.interfacePk !== CREATE_MEETING_PK)
+        return undefined;
+    const mtId = ctx.dataIds[0];
+    if (!mtId) {
+        return {
+            status: 'SKIPPED',
+            reason: 'create_meeting 未返回会议 id，无法补建占用/回执/签到，请到会议详情页确认。',
+        };
+    }
+    const main = ctx.payload.mainTable;
+    const warnings = [];
+    const created = {};
+    // ① 会议室占用：仅在指定了会议室时写入。
+    const address = main.address === undefined || main.address === null ? '' : String(main.address).trim();
+    if (address === '') {
+        warnings.push('会议未指定会议室（address），已跳过占用写入。');
+    }
+    else {
+        const result = await writeOne(ctx.env, 'create_roomusage', {
+            mt_id: mtId,
+            room_id: address,
+            startdate: main.begin_datetime,
+            enddate: main.end_datetime,
+        });
+        if (result.ok)
+            created.roomUsage = [address];
+        else {
+            warnings.push(`会议室占用写入失败（${result.error}）：该会议不会被会议室冲突检测识别，`
+                + '建议到会议详情页确认，或按需重新创建占用。');
+        }
+    }
+    // ② 回执 + ③ 签到：按 hrm_members 逐人补齐。
+    const members = splitIds(main.hrm_members);
+    if (members.length === 0) {
+        warnings.push('会议未提供具体参会人员（hrm_members 为空），已跳过回执与签到写入：'
+            + '参会人冲突检测与签到/补签都依赖这些记录；若通过 org_members 指定了部门，本 CLI 不展开部门成员，'
+            + '请到会议详情页确认参会人后按需补建。');
+    }
+    else {
+        const receiptFailed = [];
+        const signFailed = [];
+        for (const memberId of members) {
+            const receipt = await writeOne(ctx.env, 'create_meeting_receipt', {
+                mt_id: mtId,
+                member_type: MEMBER_TYPE_ATTENDEE,
+                member_id: memberId,
+                member_manager: memberId,
+            });
+            if (receipt.ok)
+                (created.receipt ??= []).push(memberId);
+            else
+                receiptFailed.push(`${memberId}（${receipt.error}）`);
+            const sign = await writeOne(ctx.env, 'create_meeting_sign', {
+                mt_id: mtId,
+                user_id: memberId,
+            });
+            if (sign.ok)
+                (created.sign ??= []).push(memberId);
+            else
+                signFailed.push(`${memberId}（${sign.error}）`);
+        }
+        if (receiptFailed.length > 0) {
+            warnings.push(`回执写入失败 ${receiptFailed.length}/${members.length} 人：${receiptFailed.join('、')}。`
+                + '参会人冲突检测以回执表为准，缺失将导致该会议的参会人冲突漏检。');
+        }
+        if (signFailed.length > 0) {
+            warnings.push(`签到记录写入失败 ${signFailed.length}/${members.length} 人：${signFailed.join('、')}。`
+                + '这些人将无法通过 meeting.eb.sign.mark 补签（无签到记录可定位）。');
+        }
+    }
+    return {
+        status: warnings.length === 0 ? 'COMPLETE' : 'PARTIAL',
+        mtId,
+        created,
+        ...(warnings.length > 0 ? { warnings } : {}),
+        note: 'eBuilder 自定义接口 create_meeting 不会像页面建会那样自动生成占用/回执/签到，'
+            + '本步骤由 CLI 按「会议 + 参会人」补齐，供会议室/参会人冲突检测与签到补签使用。',
+    };
+};