weaver-work-cli 0.1.1 → 0.1.4

package/dist/shortcuts/plan/operations/write.js

@@ -0,0 +1,710 @@
+import { isPlanErrorType, planApiError, planPartialError, planValidationError } from '../errors.js';
+import { businessMessage, isDatajsonSuccess, isFlagSuccess, isWeaverCodeSuccess, } from '../host.js';
+import { POST_STATUS_LABELS, SCHEMA_ID, SCHEMA_REPORT_TYPE, planSuccess, schemaOf, } from './types.js';
+import { assertLinkSupported, assertReportType, compact, defaultRemindContent, ensureConfirmLease, fingerprint, resolveSerialNumber, resolveYear, toIdListText, toIdString, } from './shared.js';
+import { buildDetailUrl, lookupReport, resolveLink } from './link.js';
+const CONTINUATION_TTL_SECONDS = 600;
+const REMIND_MESSAGE_EVENT_CODE = 14;
+const BODY_KEYS = ['content', 'summary', 'plans'];
+function textField(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string') {
+        throw planValidationError('field_invalid', `${field} 必须是字符串（支持 HTML 片段）`);
+    }
+    return value;
+}
+function bodyFields(args) {
+    const content = textField(args.content, 'content');
+    const summary = textField(args.summary, 'summary');
+    const plans = textField(args.plans, 'plans');
+    if (content === undefined && summary === undefined && plans === undefined) {
+        throw planValidationError('body_required', 'content（工作成效）、summary（总结心得）、plans（计划内容）至少提供一个');
+    }
+    return { content, summary, plans };
+}
+/** eb 链路报告名称：源资料要求按年份、类型、周期动态设置。 */
+export function buildEbTitle(userName, type, year, serialNumber) {
+    switch (type) {
+        case 'week':
+            return `${userName}${year}年第${serialNumber}周的报告`;
+        case 'month':
+            return `${userName}${year}年${serialNumber}月的报告`;
+        case 'season':
+            return `${userName}${year}年第${serialNumber}季度的报告`;
+        case 'halfYear':
+            return `${userName}${year}年年中报告`;
+        case 'year':
+            return `${userName}${year}年年度报告`;
+        default:
+            return `${userName}${year}年的报告`;
+    }
+}
+/** apply 阶段复用 prepare 的快照：允许原样重发，拒绝被改写的业务字段。 */
+function payloadFromLease(args, lease, businessKeys) {
+    const payload = { ...(lease.payload || {}) };
+    for (const key of businessKeys) {
+        if (args[key] !== undefined && String(args[key]) !== String(payload[key])) {
+            throw planValidationError('target_changed', `${key} 与 prepare 时的快照不一致，请重新执行 prepare`);
+        }
+    }
+    return payload;
+}
+/** apply 阶段重新判定链路，避免 prepare 与 apply 之间租户版本变化。 */
+async function assertSameLink(host, expected) {
+    const current = await resolveLink(host);
+    if (current.link !== expected) {
+        throw planValidationError('link_changed', `接口链路已从 ${expected} 变为 ${current.link}，请重新执行 prepare`);
+    }
+    return current.link;
+}
+function isNetworkError(error) {
+    return isPlanErrorType(error, 'network');
+}
+async function issueConfirmation(env, operation, link, payload) {
+    const session = await env.host.getSession();
+    return env.continuation.issue({
+        operation,
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        link,
+        payload,
+        fingerprint: fingerprint(payload),
+    }, CONTINUATION_TTL_SECONDS * 1000);
+}
+async function sendWrite(env, operation, request, uncertainty) {
+    try {
+        return await env.host.request({ ...request, operation });
+    }
+    catch (error) {
+        if (isNetworkError(error)) {
+            throw planPartialError(uncertainty.message, uncertainty.partialData, { stage: uncertainty.stage });
+        }
+        throw error;
+    }
+}
+// ---------------------------------------------------------------------------
+// 新建报告
+// ---------------------------------------------------------------------------
+const CREATE_KEYS = ['content', 'summary', 'plans', 'year', 'type', 'serialNumber', 'title'];
+const planReportCreatePrepare = {
+    name: 'plan.report.create.prepare',
+    resource: 'plan',
+    method: 'report.create.prepare',
+    action: 'plan.report.create.prepare',
+    summary: '准备新建报告：校验必填、默认年份、按周期查重并生成确认预览，不写入',
+    capability: 'plan',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        content: { type: 'string', description: '工作成效（支持 HTML 片段）' },
+        summary: { type: 'string', description: '总结心得（支持 HTML 片段）' },
+        plans: { type: 'string', description: '计划内容（支持 HTML 片段）' },
+        year: { type: 'integer', description: '报告年份；缺省取本年' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期' },
+        title: { type: 'string', description: '报告名称；eb 链路可由 userName 自动生成' },
+        userName: { type: 'string', minLength: 1, description: '当前登录人姓名，eb 链路自动生成报告名称时必填（可由 weaver-e10-hrm 解析）' },
+    }, {
+        required: ['type', 'serialNumber'],
+        anyOf: [{ required: ['content'] }, { required: ['summary'] }, { required: ['plans'] }],
+    }),
+    handler: async (args, env) => {
+        const { host, continuation } = env;
+        const body = bodyFields(args);
+        const year = resolveYear(args.year);
+        const type = assertReportType(args.type);
+        const serialNumber = resolveSerialNumber(args.serialNumber);
+        const linkInfo = await resolveLink(host);
+        const existing = await lookupReport(host, linkInfo.link, { year, type, serialNumber });
+        if (existing.exists) {
+            return planSuccess('plan.report.create.prepare', {
+                status: 'ALREADY_EXISTS',
+                link: linkInfo.link,
+                targets: { year, type, serialNumber },
+                existingReport: existing.report,
+                hint: '该周期报告已存在，不得重复创建；请先询问用户是否改为编辑该报告',
+                warnings: existing.warnings,
+            });
+        }
+        const explicitTitle = textField(args.title, 'title');
+        let title = explicitTitle ?? null;
+        if (!title && linkInfo.link === 'eb') {
+            const userName = textField(args.userName, 'userName');
+            if (!userName) {
+                throw planValidationError('userName_required', 'eb 链路需要动态生成报告名称，请先通过 weaver-e10-hrm 解析当前登录人姓名后传入 userName，或直接传入 title');
+            }
+            title = buildEbTitle(userName, type, year, serialNumber);
+        }
+        const payload = {
+            ...(body.content === undefined ? {} : { content: body.content }),
+            ...(body.summary === undefined ? {} : { summary: body.summary }),
+            ...(body.plans === undefined ? {} : { plans: body.plans }),
+            year,
+            type,
+            serialNumber,
+            ...(title ? { title } : {}),
+        };
+        const token = await issueConfirmation(env, 'plan.report.create.apply', linkInfo.link, payload);
+        return planSuccess('plan.report.create.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            link: linkInfo.link,
+            targets: { year, type, serialNumber },
+            preview: payload,
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            warnings: existing.warnings,
+        });
+    },
+};
+const planReportCreateApply = {
+    name: 'plan.report.create.apply',
+    resource: 'plan',
+    method: 'report.create.apply',
+    action: 'plan.report.create.apply',
+    summary: '提交新建报告；必须在用户明确确认后调用，且要求 prepare 返回的 continuation',
+    capability: 'plan',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        content: { type: 'string' },
+        summary: { type: 'string' },
+        plans: { type: 'string' },
+        year: { type: 'integer' },
+        type: { ...SCHEMA_REPORT_TYPE },
+        serialNumber: { type: 'integer', minimum: 1 },
+        title: { type: 'string' },
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await ensureConfirmLease(args, 'plan.report.create.apply', env);
+        const payload = payloadFromLease(args, lease, [...CREATE_KEYS]);
+        const link = await assertSameLink(env.host, lease.link ?? 'standard');
+        const session = await env.host.getSession();
+        const year = resolveYear(payload.year);
+        const type = assertReportType(payload.type);
+        const serialNumber = resolveSerialNumber(payload.serialNumber);
+        const existing = await lookupReport(env.host, link, { year, type, serialNumber });
+        if (existing.exists) {
+            throw planValidationError('report_exists', '该周期报告已存在，禁止重复创建；请改用 plan.report.update.prepare 编辑');
+        }
+        const response = await sendWrite(env, 'plan.report.create.apply', link === 'standard'
+            ? {
+                method: 'POST',
+                path: '/api/workrelate/plan/workreport/create',
+                body: {
+                    workReport: {
+                        content: payload.content ?? '',
+                        summary: payload.summary ?? '',
+                        plans: payload.plans ?? '',
+                        year,
+                        type,
+                        serialNumber,
+                    },
+                },
+            }
+            : {
+                method: 'POST',
+                path: '/api/ebuilder/form/formdata/v2/saveFormData/plan_createPlan',
+                body: {
+                    datajson: {
+                        operationinfo: { printCost: false },
+                        datas: [{
+                                mainTable: compact({
+                                    f_content: payload.content,
+                                    f_summary: payload.summary,
+                                    f_plans: payload.plans,
+                                    f_title: payload.title,
+                                    f_year: year,
+                                    f_type: type,
+                                    f_serial_number: serialNumber,
+                                    f_post_status: '0',
+                                }),
+                            }],
+                        header: { operator: session.userId },
+                    },
+                },
+            }, {
+            message: '创建报告请求发送后连接中断，报告是否已创建不确定，禁止自动重试；请先用 plan.report.get 按周期回查',
+            partialData: { targets: { year, type, serialNumber } },
+            stage: 'create',
+        });
+        const result = { link, status: 'COMPLETE' };
+        if (link === 'standard') {
+            if (!isFlagSuccess(response)) {
+                throw planApiError('business_error', businessMessage(response), { stage: 'create' });
+            }
+            const reportId = response?.workReport?.id ?? null;
+            result.reportId = reportId === null ? null : String(reportId);
+            result.title = response?.workReport?.title ?? payload.title ?? null;
+        }
+        else {
+            if (!isDatajsonSuccess(response)) {
+                throw planApiError('business_error', businessMessage(response), { stage: 'create' });
+            }
+            const dataIds = response?.datajson?.dataIds;
+            const reportId = Array.isArray(dataIds) && dataIds.length > 0 ? String(dataIds[0]) : null;
+            result.reportId = reportId;
+            result.title = payload.title ?? null;
+        }
+        result.detailUrl = await buildDetailUrl(env.host, link, result.reportId ?? null);
+        return planSuccess('plan.report.create.apply', result);
+    },
+};
+// ---------------------------------------------------------------------------
+// 修改报告
+// ---------------------------------------------------------------------------
+const planReportUpdatePrepare = {
+    name: 'plan.report.update.prepare',
+    resource: 'plan',
+    method: 'report.update.prepare',
+    action: 'plan.report.update.prepare',
+    summary: '准备修改报告：定位目标报告、合并改动并生成 before/after 预览，不写入',
+    capability: 'plan',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        id: { ...SCHEMA_ID, description: '报告 id；不传时按周期定位' },
+        year: { type: 'integer', description: '报告年份' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期' },
+        creatorUserId: { ...SCHEMA_ID, description: '报告创建人 id；缺省为当前登录人' },
+        content: { type: 'string', description: '新的工作成效' },
+        summary: { type: 'string', description: '新的总结心得' },
+        plans: { type: 'string', description: '新的计划内容' },
+    }, {
+        anyOf: [{ required: ['id'] }, { required: ['type', 'serialNumber'] }],
+    }),
+    handler: async (args, env) => {
+        const changed = bodyFields(args);
+        const target = await locateTarget(args, env);
+        const before = target.report
+            ? {
+                content: target.report.content ?? '',
+                summary: target.report.summary ?? '',
+                plans: target.report.plans ?? '',
+            }
+            : null;
+        const after = {
+            content: changed.content ?? before?.content ?? '',
+            summary: changed.summary ?? before?.summary ?? '',
+            plans: changed.plans ?? before?.plans ?? '',
+        };
+        const payload = {
+            reportId: target.reportId,
+            ...after,
+            year: target.report?.year ?? (args.year === undefined || args.year === '' ? null : resolveYear(args.year)),
+            type: target.report?.type ?? (args.type === undefined ? null : assertReportType(args.type)),
+            serialNumber: target.report?.serialNumber
+                ?? (args.serialNumber === undefined || args.serialNumber === '' ? null : resolveSerialNumber(args.serialNumber)),
+        };
+        const token = await issueConfirmation(env, 'plan.report.update.apply', target.link, payload);
+        return planSuccess('plan.report.update.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            link: target.link,
+            preview: { reportId: target.reportId, title: target.title, before, after, precheck: target.precheck },
+            changedFields: BODY_KEYS.filter((key) => changed[key] !== undefined),
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            warnings: target.warnings,
+        });
+    },
+};
+const planReportUpdateApply = {
+    name: 'plan.report.update.apply',
+    resource: 'plan',
+    method: 'report.update.apply',
+    action: 'plan.report.update.apply',
+    summary: '提交修改报告；必须在用户明确确认后调用，且要求 prepare 返回的 continuation',
+    capability: 'plan',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        content: { type: 'string' },
+        summary: { type: 'string' },
+        plans: { type: 'string' },
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await ensureConfirmLease(args, 'plan.report.update.apply', env);
+        const payload = payloadFromLease(args, lease, [...BODY_KEYS]);
+        const link = await assertSameLink(env.host, lease.link ?? 'standard');
+        const reportId = toIdString(payload.reportId, 'reportId');
+        const session = await env.host.getSession();
+        const response = await sendWrite(env, 'plan.report.update.apply', link === 'standard'
+            ? {
+                method: 'POST',
+                path: `/api/workrelate/plan/workreport/${encodeURIComponent(reportId)}`,
+                body: {
+                    workReport: {
+                        content: payload.content ?? '',
+                        summary: payload.summary ?? '',
+                        plans: payload.plans ?? '',
+                    },
+                },
+            }
+            : {
+                method: 'POST',
+                path: '/api/ebuilder/form/formdata/v2/updateFormData/plan_updatePlan',
+                body: {
+                    datajson: {
+                        operationinfo: { printCost: false },
+                        datas: [{
+                                mainTable: compact({
+                                    id: reportId,
+                                    f_content: payload.content,
+                                    f_summary: payload.summary,
+                                    f_plans: payload.plans,
+                                }),
+                            }],
+                        header: { operator: session.userId },
+                    },
+                },
+            }, {
+            message: '修改报告请求发送后连接中断，报告是否已更新不确定，禁止自动重试；请先用 plan.report.get 回查',
+            partialData: { reportId },
+            stage: 'update',
+        });
+        if (link === 'standard') {
+            const updated = response?.isUpdated;
+            if (!(updated === '1' || updated === 1 || updated === true)) {
+                throw planApiError('business_error', businessMessage(response), { stage: 'update' });
+            }
+        }
+        else if (!isDatajsonSuccess(response)) {
+            throw planApiError('business_error', businessMessage(response), { stage: 'update' });
+        }
+        return planSuccess('plan.report.update.apply', {
+            link,
+            status: 'COMPLETE',
+            reportId,
+            detailUrl: await buildDetailUrl(env.host, link, reportId),
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 发布报告
+// ---------------------------------------------------------------------------
+const TARGET_SCHEMA = {
+    id: { ...SCHEMA_ID, description: '报告 id；与周期参数二选一' },
+    year: { type: 'integer', description: '报告年份' },
+    type: { ...SCHEMA_REPORT_TYPE, description: '报告类型' },
+    serialNumber: { type: 'integer', minimum: 1, description: '报告周期' },
+    creatorUserId: { ...SCHEMA_ID, description: '报告创建人 id；缺省为当前登录人' },
+};
+async function locateTarget(args, env) {
+    const linkInfo = await resolveLink(env.host);
+    const query = args.id !== undefined && args.id !== ''
+        ? {
+            id: toIdString(args.id, 'id'),
+            ...(args.type !== undefined && args.serialNumber !== undefined
+                ? { year: resolveYear(args.year), type: assertReportType(args.type), serialNumber: resolveSerialNumber(args.serialNumber) }
+                : {}),
+        }
+        : {
+            year: resolveYear(args.year),
+            type: assertReportType(args.type),
+            serialNumber: resolveSerialNumber(args.serialNumber),
+            ...(args.creatorUserId !== undefined && args.creatorUserId !== ''
+                ? { creatorUserId: toIdString(args.creatorUserId, 'creatorUserId') }
+                : {}),
+        };
+    const target = await lookupReport(env.host, linkInfo.link, query);
+    const warnings = [...target.warnings];
+    if (target.exists === false) {
+        throw planValidationError('not_found', '未找到目标报告，请先确认报告 id 或周期信息');
+    }
+    if (!target.report?.reportId) {
+        // eb 链路没有按报告 id 查询详情的接口，缺少周期信息时无法做写入前预检。
+        if (args.id === undefined || args.id === '') {
+            throw planValidationError('lookup_incomplete', '缺少可用于定位报告的 id 或周期信息');
+        }
+        warnings.push('当前链路无法按报告 id 预检报告状态，已跳过写入前校验；如可提供 year/type/serialNumber 将自动补检');
+        return {
+            link: linkInfo.link,
+            reportId: toIdString(args.id, 'id'),
+            report: null,
+            postStatus: null,
+            title: null,
+            precheck: 'skipped',
+            warnings,
+        };
+    }
+    return {
+        link: linkInfo.link,
+        reportId: target.report.reportId,
+        report: target.report,
+        postStatus: target.report.postStatus,
+        title: target.report.title,
+        precheck: 'checked',
+        warnings,
+    };
+}
+const planReportPublishPrepare = {
+    name: 'plan.report.publish.prepare',
+    resource: 'plan',
+    method: 'report.publish.prepare',
+    action: 'plan.report.publish.prepare',
+    summary: '准备发布报告：定位目标、校验当前发布状态并生成确认预览，不写入',
+    capability: 'plan',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...TARGET_SCHEMA }, {
+        anyOf: [{ required: ['id'] }, { required: ['type', 'serialNumber'] }],
+    }),
+    handler: async (args, env) => {
+        const target = await locateTarget(args, env);
+        if (target.postStatus === '1') {
+            throw planValidationError('already_published', '该报告已是「已发布」状态，无需重复发布');
+        }
+        const token = await issueConfirmation(env, 'plan.report.publish.apply', target.link, {
+            reportId: target.reportId,
+            title: target.title,
+            postStatus: target.postStatus,
+        });
+        return planSuccess('plan.report.publish.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            link: target.link,
+            preview: {
+                reportId: target.reportId,
+                title: target.title,
+                postStatus: target.postStatus,
+                postStatusLabel: target.postStatus === null ? null : (POST_STATUS_LABELS[target.postStatus] ?? null),
+                precheck: target.precheck,
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            warnings: target.warnings,
+        });
+    },
+};
+const planReportPublishApply = {
+    name: 'plan.report.publish.apply',
+    resource: 'plan',
+    method: 'report.publish.apply',
+    action: 'plan.report.publish.apply',
+    summary: '提交发布报告；必须在用户明确确认后调用，且要求 prepare 返回的 continuation',
+    capability: 'plan',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await ensureConfirmLease(args, 'plan.report.publish.apply', env);
+        const link = await assertSameLink(env.host, lease.link ?? 'standard');
+        const reportId = toIdString((lease.payload || {}).reportId, 'reportId');
+        const response = await sendWrite(env, 'plan.report.publish.apply', link === 'standard'
+            ? {
+                method: 'POST',
+                path: '/api/workrelate/plan/workreport/sendReport',
+                body: { workReportId: reportId },
+            }
+            : {
+                method: 'POST',
+                path: '/api/secondev/planebapp/main/sendReport',
+                body: { reportFormDataId: reportId },
+            }, {
+            message: '发布报告请求发送后连接中断，报告是否已发布不确定，禁止自动重试；请先用 plan.report.get 回查',
+            partialData: { reportId },
+            stage: 'publish',
+        });
+        if (link === 'standard') {
+            if (!isFlagSuccess(response)) {
+                throw planApiError('business_error', businessMessage(response), { stage: 'publish' });
+            }
+        }
+        else if (Number(response?.code) !== 200) {
+            throw planApiError('business_error', businessMessage(response), { stage: 'publish' });
+        }
+        return planSuccess('plan.report.publish.apply', {
+            link,
+            status: 'COMPLETE',
+            reportId,
+            detailUrl: await buildDetailUrl(env.host, link, reportId),
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 撤回报告
+// ---------------------------------------------------------------------------
+const planReportWithdrawPrepare = {
+    name: 'plan.report.withdraw.prepare',
+    resource: 'plan',
+    method: 'report.withdraw.prepare',
+    action: 'plan.report.withdraw.prepare',
+    summary: '准备撤回报告：定位目标、校验其为「已发布」状态并生成确认预览，不写入',
+    capability: 'plan',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...TARGET_SCHEMA }, {
+        anyOf: [{ required: ['id'] }, { required: ['type', 'serialNumber'] }],
+    }),
+    handler: async (args, env) => {
+        const target = await locateTarget(args, env);
+        assertLinkSupported(target.link, 'standard', 'plan.report.withdraw', 'eb 链路的撤回报告通过 ESB 动作流「eb撤回报告」实现，当前 CLI 未获得该动作流的唯一标识（uniqueIndent），请改用 weaver-e10-customesb-execute skill 执行同名动作流');
+        if (target.precheck === 'checked' && target.postStatus !== '1') {
+            throw planValidationError('not_published', '该报告当前不是「已发布」状态，无法撤回');
+        }
+        const token = await issueConfirmation(env, 'plan.report.withdraw.apply', target.link, {
+            reportId: target.reportId,
+            title: target.title,
+        });
+        return planSuccess('plan.report.withdraw.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            link: target.link,
+            preview: { reportId: target.reportId, title: target.title, postStatus: target.postStatus },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            warnings: target.warnings,
+        });
+    },
+};
+const planReportWithdrawApply = {
+    name: 'plan.report.withdraw.apply',
+    resource: 'plan',
+    method: 'report.withdraw.apply',
+    action: 'plan.report.withdraw.apply',
+    summary: '提交撤回报告（仅标准版链路）；必须在用户明确确认后调用',
+    capability: 'plan',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await ensureConfirmLease(args, 'plan.report.withdraw.apply', env);
+        const link = await assertSameLink(env.host, lease.link ?? 'standard');
+        assertLinkSupported(link, 'standard', 'plan.report.withdraw', 'eb 链路的撤回报告通过 ESB 动作流「eb撤回报告」实现，请改用 weaver-e10-customesb-execute skill 执行同名动作流');
+        const reportId = toIdString((lease.payload || {}).reportId, 'reportId');
+        const response = await sendWrite(env, 'plan.report.withdraw.apply', {
+            method: 'POST',
+            path: '/api/workrelate/plan/workreport/takeBackReport',
+            body: { id: reportId },
+        }, {
+            message: '撤回报告请求发送后连接中断，报告是否已撤回不确定，禁止自动重试；请先用 plan.report.get 回查',
+            partialData: { reportId },
+            stage: 'withdraw',
+        });
+        if (!isFlagSuccess(response)) {
+            throw planApiError('business_error', businessMessage(response), { stage: 'withdraw' });
+        }
+        return planSuccess('plan.report.withdraw.apply', {
+            link,
+            status: 'COMPLETE',
+            reportId,
+            detailUrl: await buildDetailUrl(env.host, link, reportId),
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 发送报告提交提醒（标准版链路）
+// ---------------------------------------------------------------------------
+const planReportRemindPrepare = {
+    name: 'plan.report.remind.prepare',
+    resource: 'plan',
+    method: 'report.remind.prepare',
+    action: 'plan.report.remind.prepare',
+    summary: '准备发送报告提交提醒：归一化人员 ID、按周期生成默认文案并生成确认预览，不发送',
+    capability: 'plan',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        personIds: {
+            oneOf: [
+                { type: 'array', items: { type: 'string', pattern: '^\\d+$' }, minItems: 1 },
+                { type: 'string', pattern: '^\\d+(,\\d+)*$' },
+            ],
+            description: '需要提醒的人员 ID（数组或英文逗号拼接字符串）',
+        },
+        year: { type: 'integer', description: '报告年份；缺省取本年' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期' },
+        content: { type: 'string', description: '提醒文案；缺省按周期生成默认文案' },
+    }, { required: ['personIds', 'type', 'serialNumber'] }),
+    handler: async (args, env) => {
+        const linkInfo = await resolveLink(env.host);
+        assertLinkSupported(linkInfo.link, 'standard', 'plan.report.remind', 'eb 链路未提供报告提交提醒接口；当前租户走 e10-ebuilder 链路，无法发送提交提醒');
+        const ids = toIdListText(args.personIds, 'personIds');
+        const year = resolveYear(args.year);
+        const type = assertReportType(args.type);
+        const serialNumber = resolveSerialNumber(args.serialNumber);
+        const content = textField(args.content, 'content') ?? defaultRemindContent(type, year, serialNumber);
+        const token = await issueConfirmation(env, 'plan.report.remind.apply', linkInfo.link, {
+            ids,
+            content,
+            year,
+            type,
+            serialNumber,
+        });
+        return planSuccess('plan.report.remind.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            link: linkInfo.link,
+            preview: {
+                personIds: ids.split(','),
+                targets: { year, type, serialNumber },
+                content,
+                messageEventCode: REMIND_MESSAGE_EVENT_CODE,
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const planReportRemindApply = {
+    name: 'plan.report.remind.apply',
+    resource: 'plan',
+    method: 'report.remind.apply',
+    action: 'plan.report.remind.apply',
+    summary: '提交发送报告提交提醒；必须在用户明确确认后调用，且要求 prepare 返回的 continuation',
+    capability: 'plan',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await ensureConfirmLease(args, 'plan.report.remind.apply', env);
+        const link = await assertSameLink(env.host, lease.link ?? 'standard');
+        assertLinkSupported(link, 'standard', 'plan.report.remind', 'eb 链路未提供报告提交提醒接口，无法发送提交提醒');
+        const payload = lease.payload || {};
+        const ids = toIdListText(payload.ids, 'ids');
+        const content = String(payload.content ?? '');
+        const response = await sendWrite(env, 'plan.report.remind.apply', {
+            method: 'POST',
+            path: '/api/workrelate/plan/workreportmsg/send',
+            body: { ids, content, messageEventCode: REMIND_MESSAGE_EVENT_CODE },
+        }, {
+            message: '提醒请求发送后连接中断，是否已发送不确定，禁止自动重试；请询问用户后再决定是否重发',
+            partialData: { ids, content },
+            stage: 'remind',
+        });
+        if (!isWeaverCodeSuccess(response) || !response?.data) {
+            throw planApiError('business_error', businessMessage(response), { stage: 'remind' });
+        }
+        return planSuccess('plan.report.remind.apply', {
+            link,
+            status: 'COMPLETE',
+            personIds: ids.split(','),
+            content,
+        });
+    },
+};
+export const planWriteOperations = [
+    planReportCreatePrepare,
+    planReportCreateApply,
+    planReportUpdatePrepare,
+    planReportUpdateApply,
+    planReportPublishPrepare,
+    planReportPublishApply,
+    planReportWithdrawPrepare,
+    planReportWithdrawApply,
+    planReportRemindPrepare,
+    planReportRemindApply,
+];