weaver-work-cli 0.1.22 → 0.1.24

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

@@ -65,7 +65,10 @@ function prepareDefinition(spec, entry) {
         summary: `${spec.summary}｜prepare：只读校验与请求体预览，签发 apply 所需的 continuation，不产生副作用`,
         risk: 'read-before-write',
         requiresConfirmation: true,
-        handler: (args, env) => entry.prepare(args, env),
+        handler: (args, env) => {
+            entry.validateInput?.(args);
+            return entry.prepare(args, env);
+        },
     };
 }
 /**
@@ -83,6 +86,7 @@ function applyDefinition(spec, entry) {
         requiresConfirmation: true,
         inputSchema: applySchemaOf(spec.inputSchema, base.required ?? []),
         handler: async (args, env) => {
+            entry.validateInput?.(args);
             const lease = await verifyLease(args, name, env);
             assertLeaseArgs(lease, args, name);
             assertLeaseTarget(lease, args, entry.targetKeys ?? [], name);

package/dist/shortcuts/caizhilian/operations/specs.js

@@ -271,6 +271,8 @@ export const caizhilianOperationSpecs = [
         position_attribute: LIST('岗位属性'),
         position_level_department: LIST('岗位层级-部门'),
         position_level_subcompany: LIST('岗位层级-分部'),
+        seclevel_min: INT('密级下限，范围 -999~999', { minimum: -999, maximum: 999 }),
+        seclevel_max: INT('密级上限，范围 -999~999', { minimum: -999, maximum: 999 }),
     }, ['folder_id', 'permission_type', 'obj_type'], { requiresConfirmation: true }),
     spec('folder', 'permission.delete', 'delete_folder_permission', 'high-risk-write', '删除文件夹文档权限设置', {
         folder_id: ID('文件夹 ID'),
@@ -309,6 +311,50 @@ export const caizhilianOperationSpecs = [
     spec('folder', 'permission.sync-setting', 'sync_folder_setting_permission', 'high-risk-write', '将当前文件夹的"管理员"权限设置同步到下级子文件夹', {
         id: ID('文件夹 ID'),
         keepOldSettingForAllFolders: BOOL('是否保留原有管理员设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-maintain', 'sync_folder_maintain_permission', 'high-risk-write', '将当前文件夹的"文件夹维护"权限设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有文件夹维护设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-download', 'sync_folder_download_permission', 'high-risk-write', '将当前文件夹的"下载权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有下载权限设置（true=保留，false=不保留）'),
+    }, ['id'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-delete', 'sync_folder_delete_permission', 'high-risk-write', '将当前文件夹的"删除权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有删除权限设置（true=保留，false=不保留）'),
+    }, ['id'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-copy', 'sync_folder_copy_permission', 'high-risk-write', '将当前文件夹的"复制权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有复制权限设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-create', 'sync_folder_create_permission', 'high-risk-write', '将当前文件夹的"新建文档权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有新建文档权限设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-move', 'sync_folder_move_permission', 'high-risk-write', '将当前文件夹的"移动权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有移动权限设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-participant', 'sync_folder_participant', 'high-risk-write', '将当前文件夹的"默认参与人"设置同步到下级子文件夹或历史文档', {
+        id: ID('文件夹 ID'),
+        sync_to_folder_docs: BOOL('是否同步到当前文件夹内的历史文档'),
+        sync_to_all_folders: BOOL('是否同步到所有下级文件夹'),
+        sync_to_all_sub_folder_docs: BOOL('是否同步到所有下级文件夹内的历史文档'),
+        keep_old_for_folder_docs: BOOL('原有参与人是否保留（同步到历史文档时）', { default: true }),
+        keep_old_for_all_folders: BOOL('原有参与人是否保留（同步到下级文件夹时）', { default: true }),
+        keep_old_for_all_sub_folder_docs: BOOL('原有参与人是否保留（同步到下级文件夹历史文档时）', { default: true }),
+    }, ['id'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-default-share', 'sync_folder_default_share', 'high-risk-write', '将当前文件夹的"默认共享人"设置同步到下级子文件夹或历史文档', {
+        id: ID('文件夹 ID'),
+        sync_to_folder_docs: BOOL('是否同步到当前文件夹内的历史文档'),
+        sync_to_all_folders: BOOL('是否同步到所有下级文件夹'),
+        sync_to_all_sub_folder_docs: BOOL('是否同步到所有下级文件夹内的历史文档'),
+        keep_old_default_share_for_folder_docs: BOOL('原有默认共享人是否保留（同步到历史文档时）', { default: true }),
+        keep_old_non_default_share_for_folder_docs: BOOL('原有非默认共享人是否保留（同步到历史文档时）', { default: true }),
+        keep_old_default_share_for_all_folders: BOOL('原有默认共享人是否保留（同步到下级文件夹时）', { default: true }),
+        keep_old_default_share_for_sub_folder_docs: BOOL('原有默认共享人是否保留（同步到下级文件夹历史文档时）', { default: true }),
+        keep_old_non_default_share_for_sub_folder_docs: BOOL('原有非默认共享人是否保留（同步到下级文件夹历史文档时）', { default: true }),
     }, ['id'], { requiresConfirmation: true }),
     // ── setting-attach ──────────────────────────────────────
     spec('setting-attach', 'get', 'get_setting_attach', 'read', '读取附件设置（文件设置 → 附件设置）', {}, [], {
@@ -544,11 +590,17 @@ export const caizhilianOperationSpecs = [
     spec('file-upload', 'prepare', 'prepare_upload', 'read', '准备上传（本地文件校验与元数据）', {
         file_path: FILE('本地文件绝对路径'),
         module: S('业务模块（如 document、workflow 等）'),
+        context_file: FILE('可选业务上下文 JSON 文件绝对路径（最大 64 KiB）'),
+        chat_id: S('宿主对话标识，用于隔离上传回执；默认 cli'),
+        timeout_seconds: INT('上传超时秒数（1–3600，默认 300）', { minimum: 1, maximum: 3600, default: 300 }),
     }, ['file_path', 'module']),
     spec('file-upload', 'upload', 'upload_file', 'high-risk-write', '上传文件到文件服务', {
         file_path: FILE('本地文件绝对路径'),
         module: S('业务模块（如 document、workflow 等）'),
         user_confirmed: BOOL('用户已确认上传'),
+        context_file: FILE('可选业务上下文 JSON 文件绝对路径（最大 64 KiB）'),
+        chat_id: S('宿主对话标识，用于隔离上传回执；默认 cli'),
+        timeout_seconds: INT('上传超时秒数（1–3600，默认 300）', { minimum: 1, maximum: 3600, default: 300 }),
     }, ['file_path', 'module', 'user_confirmed'], { requiresConfirmation: true }),
     // ── org ─────────────────────────────────────────────────
     spec('org', 'search-user', 'search_user', 'read', '人员浏览器检索（源 search_user → /api/hrm/common/browser/data/resource）', {

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { meetingConfirmationError, meetingPartialError, meetingValidationError } from '../errors.js';
 import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from './types.js';
-import { assertDateTimeMinute, extractRows, toIdCsv, toIdString } from './shared.js';
+import { assertDateTimeMinute, extractRows, mergeSnapshot, toIdCsv, toIdString } from './shared.js';
 const CONTINUATION_TTL_SECONDS = 600;
 const LIST_PATH = '/api/meeting/search/getMeetingList';
 function fingerprint(value) {
@@ -202,15 +202,18 @@ const meetingChangeApply = {
             caller: SCHEMA_ID,
             contacter: SCHEMA_ID,
         },
-        required: ['confirm', 'continuation', 'id'],
+        required: ['confirm', 'continuation'],
     },
     handler: async (args, env) => {
         requireConfirm(args, 'meeting.change.apply');
         const lease = await verifyLease(args, 'meeting.change.apply', env);
-        const body = normalizeChangeInput(args);
+        // 只传 confirm+continuation 时用 prepare 快照（含 prepare 时算好的 id / 字段）；
+        // 传入字段则覆盖快照，仍由 fingerprint 决定是否 target_changed。
+        const merged = mergeSnapshot(lease.payload, args);
+        const { operateType: leaseOperateType, ...mergedBody } = merged;
+        const body = normalizeChangeInput(mergedBody);
         const id = String(body.id);
         const { operateType, mtStatus } = await resolveOperateType(id, env, 'meeting.change.apply');
-        const leaseOperateType = lease.payload?.operateType;
         if (leaseOperateType && leaseOperateType !== operateType) {
             throw meetingValidationError('target_changed', `会议状态已变化（prepare 时按 ${leaseOperateType}、当前按 ${operateType}，当前状态：${mtStatus}），请重新执行 prepare 并向用户确认`);
         }

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { meetingConflictError, meetingConfirmationError, meetingPartialError, meetingValidationError } from '../errors.js';
 import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from './types.js';
-import { assertDateTimeMinute, extractConflict, toIdCsv, toIdString, } from './shared.js';
+import { assertDateTimeMinute, extractConflict, mergeSnapshot, toIdCsv, 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);
@@ -309,13 +309,15 @@ const meetingCreateApply = {
             repeatDesc: { type: 'string' },
             serviceItems: { type: 'string' },
         },
-        required: ['confirm', 'continuation', 'name', 'beginDatetime', 'endDatetime'],
+        required: ['confirm', 'continuation'],
     },
     handler: async (args, env) => {
         requireConfirm(args, 'meeting.create.apply');
         const lease = await verifyLease(args, 'meeting.create.apply', env);
         const session = await env.host.getSession();
-        const body = normalizeCreateInput(args, session.userId);
+        // 只传 confirm+continuation 时用 prepare 快照（用户已确认的内容）；传入其它字段则作为覆盖，
+        // 由下面的 fingerprint 校验决定是否 target_changed。
+        const body = normalizeCreateInput(mergeSnapshot(lease.payload, args), session.userId);
         if (lease.fingerprint !== fingerprint(body)) {
             throw meetingValidationError('target_changed', '会议内容与 prepare 时的快照不一致，请重新执行 prepare');
         }

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

@@ -21,6 +21,13 @@ import { meetingPartialError, meetingValidationError } from '../../errors.js';
 import { toIdString } from '../shared.js';
 const CONTINUATION_TTL_SECONDS = 600;
 const DATE_PATTERN = '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$';
+/** 本地时间的 yyyy-MM-dd HH:mm:ss（EB 的签到/完成时间字段要求带秒）。 */
+function formatSecondNow() {
+    const now = new Date();
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} `
+        + `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
 /** 决议状态：0未决议 / 1决议临时保存 / 2决议提交完成。 */
 const DECISION_DONE = '2';
 /** 会议状态「结束」：产生决议后会议即视为结束。 */
@@ -293,7 +300,19 @@ const signMarkPrepare = {
             throw meetingValidationError('sign_record_not_found', `未在该会议（${mtId}）中找到员工 ${userId} 的签到记录，无法补签。`
                 + '请先用 meeting.eb.sign.list 确认该会议是否已生成签到数据（若会议尚无签到记录，属建会初始化问题，需先用 meeting.eb.sign.create 初始化后再补签）。', { mtId, userId });
         }
-        const update = normalizeEbWrite(requireEndpoint('update_meeting_sign_info'), { ...args, id: recordId, mt_id: mtId }, session.userId);
+        // ⚠️ 2026-10-08 真机实测：只传 mt_id + user_id 时，update 里**没有任何时间字段**，
+        // 服务端照常返回成功、CLI 报 COMPLETE，但签到记录**一点没变**（静默无效）。
+        // 补签的语义就是"把签到时间补录为当前时间"，故缺省补当前时间，并明确告警；
+        // 补签退同理（只传 user_id 而不给 signback_time 时补当前时间）。
+        const warnings = [];
+        const patch = { ...args, id: recordId, mt_id: mtId };
+        if (patch.sign_time === undefined && patch.signback_time === undefined && patch.sign_out_status === undefined) {
+            const now = formatSecondNow();
+            patch.sign_time = now;
+            patch.is_sign = patch.is_sign ?? '1';
+            warnings.push(`未传签到时间：按"补签"语义使用当前时间 ${now}（如需指定时间请传 sign_time）`);
+        }
+        const update = normalizeEbWrite(requireEndpoint('update_meeting_sign_info'), patch, session.userId);
         const payload = { mtId, signRecordId: recordId, update };
         const token = await env.continuation.issue({
             operation: 'meeting.eb.sign.mark.apply',
@@ -316,10 +335,11 @@ const signMarkPrepare = {
             continuation: token,
             expiresInSeconds: CONTINUATION_TTL_SECONDS,
         }, {
+            warnings,
             meta: {
                 notes: [
                     '走的是**更新**（update_meeting_sign_info），不会新增签到记录。',
-                    '未传 sign_time 时签到时间仍为空，请按需补上。',
+                    '未传 sign_time / signback_time 时视为「补签」，由 CLI 用当前时间补上（preview.after 里可见实际写入值）。',
                 ],
             },
         });

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/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/shared.js

@@ -61,6 +61,34 @@ export function toIdString(value, label) {
         return value;
     throw meetingValidationError('id_invalid', `${label} 必须是数字 id（超长 id 用字符串）`);
 }
+/** 取 apply 入参里的业务字段（排除 confirm/continuation）。 */
+export function pickBusinessInput(args) {
+    const out = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (key === 'confirm' || key === 'continuation')
+            continue;
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * 标准版 apply 的入参合并：**以 prepare 快照为基**，入参里的业务字段作为覆盖。
+ *
+ * 为什么需要：prepare 已经把「用户将要确认的内容」规范化后存进 continuation，而各 apply 的
+ * 入参 schema 又要求回传 name/beginDatetime/endDatetime 等业务字段 —— 文档与调用方习惯都是
+ * 「apply 只传 confirm + continuation」，于是出现「文档说只传两个参数，实际报 name 必填」的矛盾
+ * （2026-09-23、2026-10-08 两次真机踩到）。
+ *
+ * 语义：只传 confirm+continuation → 直接用快照（即预览过的内容）；
+ * 传入了不同值 → 合并后由 fingerprint 校验报 `target_changed`（提示重新 prepare），
+ * 因此不会绕过「确认过的内容」这道闸门。
+ */
+export function mergeSnapshot(snapshot, args) {
+    const base = snapshot && typeof snapshot === 'object' ? { ...snapshot } : {};
+    return { ...base, ...pickBusinessInput(args) };
+}
 /** 逗号分隔 id 串：接受数组或字符串，输出字符串。 */
 export function toIdCsv(value, label) {
     if (value === undefined || value === null || value === '')

package/dist/shortcuts/meeting/operations/signs.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 { 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);
@@ -212,13 +212,23 @@ function signWritePair(spec) {
                 continuation: { type: 'string', minLength: 1 },
                 ...inputProps,
             },
-            required: ['confirm', 'continuation', 'id'],
+            required: ['confirm', 'continuation'],
         },
         handler: async (args, env) => {
             requireConfirm(args, applyName);
             const lease = await verifyLease(args, applyName, env);
-            const target = await resolveSignTarget(args, env, applyName);
-            const payload = { id: target.signRecordId, meetingid: target.meetingId };
+            // 只传 confirm+continuation 时用 prepare 快照（快照里已含解析好的签到记录 id 与会议 id）；
+            // 传了 id/mtId 才重新回查定位并校验一致性。
+            const business = pickBusinessInput(args);
+            let payload;
+            if (Object.keys(business).length === 0) {
+                const snapshot = lease.payload;
+                payload = { id: String(snapshot.id ?? ''), meetingid: String(snapshot.meetingid ?? '') };
+            }
+            else {
+                const target = await resolveSignTarget(mergeSnapshot(lease.payload, args), env, applyName);
+                payload = { id: target.signRecordId, meetingid: target.meetingId };
+            }
             if (lease.fingerprint !== fingerprint(payload)) {
                 throw meetingValidationError('target_changed', '签到记录或会议与 prepare 时的快照不一致，请重新执行 prepare');
             }

package/dist/shortcuts/project/operations/read.js

@@ -1,4 +1,5 @@
 import { assertDatajsonSuccess, assertWeaverSuccess, } from '../host.js';
+import { projectValidationError } from '../errors.js';
 import { SCHEMA_FILTERS, SCHEMA_FIELDS, SCHEMA_ID_STRING, SCHEMA_PAGE_NO, SCHEMA_PAGE_SIZE, projectSuccess, schemaOf, } from './types.js';
 import { compactFilters, idString, operatorId, positiveInt, queryText, } from './shared.js';
 const APP_TAG = 'weaver-project-eb';
@@ -36,12 +37,12 @@ function outputFields(value) {
     if (value === undefined)
         return null;
     if (!Array.isArray(value) || value.length === 0) {
-        throw new Error('fields 必须是非空字符串数组');
+        throw projectValidationError('field_invalid', 'fields 必须是非空字符串数组');
     }
     const fields = [];
     for (const item of value) {
         if (typeof item !== 'string' || !/^[A-Za-z]/.test(item) || /[^A-Za-z0-9_]/.test(item)) {
-            throw new Error('fields 包含非法字段名');
+            throw projectValidationError('field_invalid', 'fields 包含非法字段名');
         }
         fields.push(item);
     }
@@ -65,12 +66,12 @@ function normalizeFieldNames(value, inputName) {
     if (value === undefined)
         return [];
     if (!Array.isArray(value) || value.length === 0) {
-        throw new Error(`${inputName} 必须是非空字符串数组`);
+        throw projectValidationError('field_invalid', `${inputName} 必须是非空字符串数组`);
     }
     const names = [];
     for (const item of value) {
         if (typeof item !== 'string' || item.trim() === '' || item.length > 100) {
-            throw new Error(`${inputName} 包含非法字段名`);
+            throw projectValidationError('field_invalid', `${inputName} 包含非法字段名`);
         }
         names.push(item);
     }
@@ -130,7 +131,7 @@ async function decorateDetailUrls(host, operation, datajson) {
 }
 function table(value) {
     if (value !== 'task' && value !== 'project') {
-        throw new Error('table must be task or project');
+        throw projectValidationError('field_invalid', 'table 必须是 task 或 project');
     }
     return value;
 }
@@ -209,7 +210,7 @@ function listOperation(name, path, nameField, descField, statusField) {
             await resolveCurrentUserFilters(filters, host);
             const allStatuses = args.allStatuses === true;
             if (allStatuses && (filters.sys_status !== undefined || filters[statusField] !== undefined)) {
-                throw new Error("allStatuses 不能与 sys_status 或业务状态同时传");
+                throw projectValidationError('field_conflict', 'allStatuses 不能与 sys_status 或业务状态同时传');
             }
             if (allStatuses) {
                 delete filters.sys_status;

package/dist/shortcuts/workflow/continuation.js

@@ -189,15 +189,20 @@ export function continuationReplayError(replay, expectedOperation) {
         return workflowAlreadyAppliedError(operation, replay);
     }
     if (replay.state === 'saving') {
-        // 写入请求已发出但结果未知：一律按"结果不确定"处理（先只读核对，禁止重复提交）。
-        // 恢复路径按命令形态分述：单命令（batchSubmit）没有 Prepare 可重跑，只能等幂等窗口过去后原样重跑。
-        const recovery = /Apply$/u.test(operation)
-            ? '确认未生效后再重跑对应的 Prepare 获取新句柄。'
-            : '确认未生效后，等本次写入的幂等保护窗口过去（约 1 分钟）再原样重跑同一条命令（同一批 requestId 在窗口内会被拦住）。';
-        return workflowPartialError('该 continuation 对应的上一次执行**已经发出写入请求，但结果未确认**（进程被中止或回执丢失），'
-            + '本次未执行、也不要重复提交。请先只读核对（如 workflow.search --category done --requestId <目标ID>'
-            + '，或 workflow.search --category mine 看是否已出现目标条目）确认真实状态，'
-            + recovery, replay, { stage: 'continuation_replay', ...replay });
+        // 写入请求已发出但结果未知：一律按"结果不确定"处理，**本次不执行、也不重放**。
+        //
+        // 恢复路径按**句柄形态**分述，且**不再出现"等一会儿原样重跑"**——`createForm` 签发的
+        // `wc-` 句柄是没有幂等窗口的（`consume` 不传 `ttlMs`，一次性且永久），"等约 1 分钟再跑"
+        // 对它是结构性无效的死路（2026-09-28 用户裁定改写）。批量写侧虽有 60s 确定性键窗口，
+        // 但同样不该由模型自动重跑。
+        const recovery = operation === 'workflow.createForm'
+            ? '要重新发起，请**重新执行 workflow.createForm 获取新句柄**（本次句柄已消费，重发同一句柄无效）。'
+            : /Apply$/u.test(operation)
+                ? '确认未生效后，重跑对应的 Prepare 获取新句柄。'
+                : '该命令没有可重跑的 Prepare，也**不要原样重跑**；请把结果如实告知用户。';
+        return workflowPartialError('该 continuation 对应的上一次执行**已经发出写入请求，但结果未确认**（进程被中止或回执丢失），本次未执行。'
+            + '**请把"上一次结果未确认"如实告知用户并停下，不要自行继续**'
+            + '（不要重试、不要改用其它命令反复推断、不要替用户下结论）。' + recovery, replay, { stage: 'continuation_replay', ...replay });
     }
     if (replay.state === 'claimed') {
         // 只抢到句柄、未发出任何写入：并发的另一次执行正在占用，等它结束再重试即可。

package/dist/shortcuts/workflow/endpoints.js

@@ -124,10 +124,20 @@ export const FORM_ENDPOINTS = {
     create: '/api/workflow/core/flow/create',
     /** 提交（复用查询侧同一路径） */
     submit: '/api/workflow/core/paService/v1/submitRequest',
-    /** 节点符合性校验 */
+    /**
+     * 节点字段校验的**第一跳**：轻量预检。
+     *
+     * 服务端只回一个布尔（是否需要把校验结果弹给用户），据此决定要不要再去取详细规则集
+     * （`conformanceSet` + `verificationConditionRule`）。开关 `passPopUpPrompt`/`noPassPrompt`
+     * 都为真时前端**不调**本接口，直接取详细规则集（2026-09-28 双 HAR 实证）。
+     */
+    verifyNodeFieldByList: '/api/workflow/core/verification/verifyNodeFieldByList',
+    /** 节点符合性校验（详细规则集，仅在需要展示校验结果时才取） */
     conformanceSet: '/api/bs/workflow/pathdef/nodeConformance/getConformanceSetByVerification',
     verificationRequestData: '/api/workflow/core/verification/getRequestDataByRequestId',
     verificationConditionRule: '/api/bs/workflow/pathdef/nodeConformance/verificationConditionRule',
+    /** 提交已创建的流程（创建后页面重载拿到 view 页鉴权再提交，与真机同路径） */
+    flowSubmit: '/api/workflow/core/flow/submit',
     /** 租户级文件上传设置（单文件大小上限 + 格式黑白名单） */
     tenantSetting: '/api/file/tenant/setting',
 };