weaver-work-cli 0.1.1 → 0.1.4

package/dist/shortcuts/ehr/operations/recruit-write.js

@@ -0,0 +1,1629 @@
+import { createHash } from 'node:crypto';
+import { ehrConfirmationError, ehrPartialError, ehrValidationError, EhrCliError } from '../errors.js';
+import { WRITE, ehrSuccess, schemaOf, } from './types.js';
+const CONTINUATION_TTL_SECONDS = 600;
+function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
+}
+function requireConfirm(args, action) {
+    if (args.confirm !== true) {
+        throw ehrConfirmationError(action, { hint: '重新调用时传入 confirm=true 与 prepare 返回的 continuation' });
+    }
+}
+/** 校验 continuation 与当前登录上下文一致，避免切换租户/账号后误执行写操作。 */
+async function verifyLease(args, action, env) {
+    const lease = await env.continuation.verify(args.continuation, action);
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+        throw ehrValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+    }
+    return lease;
+}
+function isNetworkError(error) {
+    return error instanceof EhrCliError && error.type === 'network';
+}
+async function requireRecruitCache(env) {
+    if (!env.recruitContext) {
+        throw ehrValidationError('recruit_context_unavailable', '招聘上下文加载器未初始化');
+    }
+    return env.recruitContext.load(env.host);
+}
+/** 建前查重：按手机号搜人才库（total 恒 0 平台缺陷，以 data.data[] 非空为准）。 */
+async function checkDuplicateByMobile(env, cache, mobile) {
+    const talent = cache.lists.talent;
+    const objId = cache.forms.talent_pool?.objId;
+    if (!talent?.listId || !objId) {
+        throw ehrValidationError('recruit_context_missing', '当前环境未解析到人才库菜单/表单，无法执行建前查重');
+    }
+    const fields = cache.fields[objId] || {};
+    if (!fields.telephone) {
+        throw ehrValidationError('recruit_field_missing', '环境缓存缺人才手机字段(telephone)，无法查重');
+    }
+    const mobileField = `field_${fields.telephone}`;
+    const tableuid = randomHex32();
+    const response = (await env.host.request({
+        path: `/api/ebuilder/form/list/getListDatas?passid=${objId}&cid=${objId}`,
+        body: {
+            current: 1,
+            pageSize: 10,
+            tableuid,
+            listId: talent.listId,
+            searchParamData: {
+                searchType: '3',
+                commonSearchFields: { [mobileField]: [{ [mobileField]: mobile, [`${mobileField}_condition_type`]: 'like' }] },
+                type: 'and',
+            },
+            terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1, recheckQuery: 1,
+            isFollow: 0, isShareToMe: 0, filterCondition: {},
+            cusMenuId: talent.cusMenuId, urlPageTitle: '人才库', menuName: talent.menuName || '人才管理',
+        },
+        headers: { ebBusinessId: talent.listId },
+    }));
+    return response?.data?.data || [];
+}
+/** 渠道名称 → 字典 optionId（dict.raw 精确匹配，找不到必须报错，禁止臆造 optionId）。 */
+function channelOptionId(cache, name) {
+    for (const item of cache.dict?.raw || []) {
+        if (item.selection_name === name)
+            return item.option_id;
+    }
+    throw ehrValidationError('channel_not_found', `渠道「${name}」未在数据字典中找到，请从已知渠道选择（不得臆造 optionId）`);
+}
+function validateNameMobile(name, mobile) {
+    const nameText = typeof name === 'string' ? name.trim() : '';
+    const mobileText = typeof mobile === 'string' ? mobile.trim() : '';
+    if (!nameText)
+        throw ehrValidationError('name_required', 'name（姓名）必填');
+    if (!/^\d{6,20}$/.test(mobileText))
+        throw ehrValidationError('mobile_invalid', 'mobile 必须是 6-20 位数字手机号');
+    return { name: nameText, mobile: mobileText };
+}
+function randomHex32() {
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function randomHex6() {
+    const bytes = new Uint8Array(3);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function cacheObjId(cache, logic, purpose) {
+    const objId = cache.forms[logic]?.objId;
+    if (!objId) {
+        throw ehrValidationError('recruit_form_missing', `环境缓存缺少表单 ${logic} 的 objId（${purpose}可能未启用）`);
+    }
+    return objId;
+}
+function cacheFormId(cache, logic) {
+    const entry = cache.forms[logic];
+    return entry?.formId || entry?.objId || '';
+}
+/** 表单类 esb 按钮解析（POST getFormButtons type=1）→ 扁平 actions[]（带 _btn=按钮名） */
+async function getFormActions(host, objId) {
+    const response = (await host.request({
+        path: '/api/ebuilder/form/data/getFormButtons',
+        body: {
+            layoutType: 'formLayout', objId, dataId: '', formDataId: '',
+            type: '1', fromRecycle: false, otherOperator: '', objectAppId: '',
+            browser: 'Chrome', isTamper: '0',
+        },
+    }));
+    const buttons = response?.data?.buttons || (Array.isArray(response?.data) ? response.data : []);
+    const actions = [];
+    for (const button of buttons) {
+        for (const action of button?.actions || [])
+            actions.push({ ...action, _btn: button.name });
+    }
+    return actions;
+}
+/** 列表类 esb 按钮解析（催评）：GET getListButtons/{listId}?passid */
+async function getListActions(host, listId, passId) {
+    const response = (await host.request({
+        path: `/api/ebuilder/form/list/getListButtons/${listId}?passid=${passId}`,
+    }));
+    const buttons = response?.data?.buttons || (Array.isArray(response?.data) ? response.data : []);
+    const actions = [];
+    for (const button of buttons) {
+        for (const action of button?.actions || [])
+            actions.push({ ...action, _btn: button.name });
+    }
+    return actions;
+}
+/** 从 actions 挑 actionType=esb 且名称匹配（含 include 关键词、排除 exclude）的 id */
+function pickEsbActionId(actions, include, exclude = []) {
+    const match = (name) => {
+        if (!name)
+            return false;
+        if (exclude.some((word) => name.includes(word)))
+            return false;
+        return include.some((word) => name.includes(word));
+    };
+    for (const action of actions) {
+        if (action.actionType === 'esb' && match(action.name || action._btn || action.text))
+            return String(action.id);
+    }
+    return null;
+}
+/** 找不到 esb 按钮 → 明确阻断（不编造 esbActionIds） */
+function requireEsbActionId(objId, include, exclude = []) {
+    throw ehrValidationError('esb_action_unresolved', `当前环境未取到动作流配置（按钮名称需含：${include.join('/')}，objId=${objId}），请确认对应表单已部署或联系管理员`);
+}
+/** 触发动作流 runEsb（dataIds=目标记录 id，esbActionIds=按钮配置解析） */
+async function runEsb(host, objId, dataIds, esbActionIds) {
+    const response = (await host.request({
+        path: `/api/ebuilder/form/esb/runEsb?objId=${objId}`,
+        body: { dataIds, esbActionIds, objId },
+    }));
+    return response?.data || {};
+}
+/** ds/options 运行时解析枚举（面试方式/轮次/结果等）：name → optionId */
+async function getDsOptions(host, objId, fieldId, groupId) {
+    const response = (await host.request({
+        path: '/api/ebuilder/common/ds/options',
+        query: { fieldName: fieldId, objId, sourceType: 'FORM', groupId },
+    }));
+    const map = {};
+    for (const option of response?.data || []) {
+        if (option?.name && option?.id)
+            map[option.name] = String(option.id);
+    }
+    return map;
+}
+/** 人员名称 → userId（门户字段 browser/complete/resource） */
+async function resolvePersonId(host, fieldId, keyword) {
+    const response = (await host.request({
+        path: '/api/ebuilder/form/common/browser/complete/resource',
+        body: { formParam: { fieldId, searchValue: keyword }, 'formParam.fieldId': fieldId, 'formParam.searchValue': keyword },
+    }));
+    const list = response?.data?.data || response?.data || [];
+    const first = list[0];
+    return first ? String(first.id || first.value || '') || null : null;
+}
+/** 安排面试专用：面试计划门户字段 id 映射（talent/candidate_manage/interviewer/position...） */
+async function getInterviewPortalFieldIds(host) {
+    const response = (await host.request({
+        path: '/api/recruit/candidate/getFieldIdsForInterview',
+    }));
+    return response?.data || {};
+}
+/** saveFormData：新建（rightType 0）或更新（rightType 2，带 formDataId/updateTimeStamp/layoutId） */
+async function saveFormData(host, params) {
+    const layoutId = params.layoutId || params.formId; // getFormLayout GET 405 不可靠，新建回退 formId（与 mjs 一致）
+    const customParam = {
+        objId: params.objId,
+        name: params.name,
+        firstDataName: params.name,
+        isFlowEnd: false,
+        otherOperator: '',
+        dataStatus: 'submit',
+        rightType: params.rightType || '0',
+        appId: params.appId,
+    };
+    const formData = {
+        module: 'ebuilderform',
+        client: 'pc',
+        dataStatus: 'submit',
+        form: { id: params.formId },
+        formLayout: { id: layoutId },
+        dataDetails: params.dataDetails,
+    };
+    if (params.formDataId)
+        formData.id = params.formDataId;
+    if (params.updateTimeStamp)
+        formData.updateTimeStamp = params.updateTimeStamp;
+    const response = (await host.request({
+        path: `/api/ebuilder/form/form/core/saveFormData?formId=${params.formId}`,
+        body: { module: 'ebuilderform', appId: params.appId, customParam, formData },
+    }));
+    if (!response?.status && response?.code !== 200) {
+        throw ehrValidationError('save_failed', `saveFormData 失败: ${response?.msg || JSON.stringify(response).slice(0, 200)}`);
+    }
+    return String(response?.data?.id || '');
+}
+/** 取记录当前数据（updateTimeStamp 乐观锁 + dataDetails 全字段 + 编辑布局 id） */
+async function getFormDataRecord(host, formId, dataId, objId) {
+    const response = (await host.request({
+        path: `/api/ebuilder/form/form/core/getFormDataAndLayout?formId=${formId}&dataId=${dataId}`,
+        method: 'POST',
+        body: {
+            terminalType: 'PC', dataId, formId, module: 'ebuilderform', newLayout: true,
+            cacheUid: '', layoutMultiId: '', dataCrossLayout: false, permissionId: '',
+            allReadOnly: false, initialDatas: [], dynamicData: false, cost: false,
+            customParam: { objId },
+        },
+    }));
+    const formData = response?.data?.formData || {};
+    return {
+        id: String(formData.id || ''),
+        updateTimeStamp: String(formData.updateTimeStamp || ''),
+        dataDetails: formData.dataDetails || [],
+        formLayoutId: String(response?.data?.formLayout?.id || ''),
+    };
+}
+/** getFormDataAndLayout 返回的 dataDetails → saveFormData 可提交结构 */
+function toSubmitDetails(details) {
+    const out = [];
+    for (const item of details || []) {
+        const fieldId = item?.fieldId || item?.formField?.id;
+        if (!fieldId)
+            continue;
+        const entry = { formField: { id: fieldId } };
+        if (item.dataOptions)
+            entry.dataOptions = item.dataOptions;
+        if (item.dataText)
+            entry.dataText = item.dataText;
+        if (item.value !== undefined)
+            entry.dataText = { content: String(item.value) };
+        if (!entry.dataOptions && !entry.dataText)
+            continue;
+        out.push(entry);
+    }
+    return out;
+}
+/** 候选人定位（安排面试/催评）：hasRights + prepareQuery → batchId，OtherInfo → 姓名/职位/应聘管理 id */
+async function resolveCandidateForWrite(host, cache, talentId) {
+    const talentListId = cache.lists.talent?.listId || '';
+    const extra = talentListId ? { ebBusinessId: talentListId } : {};
+    const rightsResponse = (await host.request({
+        path: `/api/recruit/talent/hasRights?formDataId=${talentId}`,
+        method: 'POST',
+        headers: extra,
+    }));
+    if (!((rightsResponse?.data || []).includes('READ'))) {
+        throw ehrValidationError('recruit_rights_denied', '当前账号无该人才的 READ 权限，无法执行写操作');
+    }
+    const rk = randomHex6();
+    const prepareResponse = (await host.request({
+        path: `/api/recruit/candidate/getCandidateCardPrepareQuery?talentId=${talentId}&randomkey_${rk}=${rk}`,
+        headers: extra,
+    }));
+    const batchId = prepareResponse?.data?.batchId;
+    if (!batchId) {
+        throw ehrValidationError('recruit_batch_id_missing', '未取到 batchId（prepareQuery 返回异常），无法定位候选人应聘批次');
+    }
+    const v = randomHex6();
+    const otherResponse = (await host.request({
+        path: `/api/recruit/candidate/getCandidateCardOtherInfo?talentId=${talentId}&batchId=${batchId}&v=${v}&randomkey_ab=ab`,
+        headers: extra,
+    }));
+    const batch = otherResponse?.data?.currentCandidateBatch || {};
+    let name = batch?.talent?.name || '';
+    if (!name) {
+        const baseResponse = (await host.request({
+            path: `/api/recruit/candidate/getCandidateCardBaseInfo?talentId=${talentId}&batchId=${batchId}&v=${v}&randomkey_cd=cd`,
+            headers: extra,
+        }));
+        name = baseResponse?.data?.talent?.hrm?.name || '';
+    }
+    return {
+        name,
+        candidateManageId: batch?.id || batch?.candidateManageId || null,
+        positionId: batch?.position?.id || null,
+        positionName: batch?.position?.name || null,
+        batchId,
+    };
+}
+/** EB 列表查询体（写操作定位记录用，同 recruit-list.mjs baseBody） */
+function writeListBody(params) {
+    return {
+        current: 1,
+        pageSize: params.pageSize,
+        tableuid: randomHex32(),
+        listId: params.listId,
+        searchParamData: { searchType: '3', type: 'and' },
+        terminal: 'PC',
+        browser: 'Chrome',
+        requiredMatch: 1,
+        mapResult: 1,
+        recheckQuery: 1,
+        isFollow: 0,
+        isShareToMe: 0,
+        filterCondition: {},
+        cusMenuId: params.cusMenuId,
+        urlPageTitle: params.title,
+        menuName: params.menuName,
+    };
+}
+function requiredString(args, key, subtype, label) {
+    const value = typeof args[key] === 'string' ? args[key].trim() : '';
+    if (!value)
+        throw ehrValidationError(subtype, `${key}（${label}）必填`);
+    return value;
+}
+// ---------------------------------------------------------------------------
+// 安排面试：prepare（候选人定位+枚举/面试官解析+摘要）→ apply（saveFormData 面试计划 → assignedInterview）
+// 迁移自 ehr 技能 recruit-arrange-interview.mjs。面试通知（runEsb 外部通知）默认不触发。
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// 新建人才：prepare（查重/渠道解析/确认摘要 + continuation）→ apply（saveFormData + initTalentBatch）
+// 迁移自 ehr 技能 recruit-new-candidate.mjs（真机已验证两步链路）。
+// ---------------------------------------------------------------------------
+const candidateCreateSchema = {
+    name: { type: 'string', minLength: 1, description: '人才姓名' },
+    mobile: { type: 'string', pattern: '^\\d{6,20}$', description: '手机号（建前查重依据）' },
+    channel: { type: 'string', description: '渠道名称（如 BOSS直聘），须为数据字典中存在的渠道' },
+};
+const candidateCreatePrepare = {
+    name: 'ehr.recruit.candidate.create.prepare',
+    resource: 'recruit',
+    method: 'candidate.create.prepare',
+    action: 'ehr.recruit.candidate.create.prepare',
+    summary: '准备新建应聘者：手机号查重 + 渠道解析 + 确认摘要，不写入任何数据',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...candidateCreateSchema }, { required: ['name', 'mobile'] }),
+    handler: async (args, env) => {
+        const { name, mobile } = validateNameMobile(args.name, args.mobile);
+        const cache = await requireRecruitCache(env);
+        const talentObj = cache.forms.talent_pool;
+        const fields = (talentObj?.objId && cache.fields[talentObj.objId]) || {};
+        if (!fields.candidate_name || !fields.telephone) {
+            throw ehrValidationError('recruit_field_missing', '环境缓存缺人才姓名字段(candidate_name)或手机字段(telephone)');
+        }
+        // 建前查重
+        const dup = await checkDuplicateByMobile(env, cache, mobile);
+        if (dup.length > 1) {
+            throw ehrValidationError('duplicate_ambiguous', `手机号 ${mobile} 存在多条候选（数据异常），请人工核对后再决定，不自动新建`);
+        }
+        const dupRow = dup[0];
+        // 渠道解析（指定了渠道但字典没有 → 明确报错）
+        let channelOption = null;
+        if (args.channel !== undefined && args.channel !== null && String(args.channel).trim() !== '') {
+            channelOption = channelOptionId(cache, String(args.channel).trim());
+        }
+        const channelName = channelOption ? String(args.channel).trim() : null;
+        const dataDetails = [
+            { formField: { id: fields.candidate_name }, content: name },
+            { formField: { id: fields.telephone }, content: mobile },
+            ...(channelOption ? [{ formField: { id: fields.channel }, dataOptions: [{ optionId: channelOption, content: channelName }] }] : []),
+        ];
+        const preview = {
+            action: '新建应聘者',
+            name,
+            mobile,
+            channel: channelName || '(未指定)',
+            duplicate: dupRow
+                ? `已存在同名/同手机号人才「${dupRow.candidate_name || dupRow.name}」（talentId=${dupRow.form_data_id || dupRow.id}）→ apply 将被阻断，不允许新建重复记录`
+                : '无重复',
+            baseUrl: (await env.host.getSession()).baseUrl,
+        };
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'ehr.recruit.candidate.create.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: { name, mobile, channel: channelName, formId: talentObj?.formId || talentObj?.objId, objId: talentObj?.objId, dataDetails },
+            fingerprint: fingerprint({ name, mobile, channel: channelName, dataDetails }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return ehrSuccess('ehr.recruit.candidate.create.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview,
+            willSubmit: { formId: talentObj?.formId || talentObj?.objId, objId: talentObj?.objId, dataDetails },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const candidateCreateApply = {
+    name: 'ehr.recruit.candidate.create.apply',
+    resource: 'recruit',
+    method: 'candidate.create.apply',
+    action: 'ehr.recruit.candidate.create.apply',
+    summary: '执行新建应聘者（saveFormData → initTalentBatch）；必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        ...candidateCreateSchema,
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['name', 'mobile', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.candidate.create.apply');
+        const { name, mobile } = validateNameMobile(args.name, args.mobile);
+        const lease = await verifyLease(args, 'ehr.recruit.candidate.create.apply', env);
+        const payload = (lease.payload || {});
+        // 指纹校验：apply 入参必须与 prepare 快照一致（防确认后偷改目标）
+        const channelName = args.channel !== undefined && args.channel !== null && String(args.channel).trim() !== ''
+            ? String(args.channel).trim()
+            : null;
+        const currentFingerprint = fingerprint({ name, mobile, channel: channelName, dataDetails: payload.dataDetails });
+        if (currentFingerprint !== lease.fingerprint) {
+            throw ehrValidationError('target_changed', '输入与 prepare 时的快照不一致（姓名/手机号/渠道被修改），请重新执行 prepare');
+        }
+        // apply 阶段再查重一次：prepare 后数据可能已被他人写入
+        const cache = await requireRecruitCache(env);
+        const dup = await checkDuplicateByMobile(env, cache, mobile);
+        if (dup.length > 0) {
+            const row = dup[0];
+            throw ehrValidationError('duplicate_blocked', `查重命中：手机号已存在「${row.candidate_name || row.name}」（talentId=${row.form_data_id || row.id}），不允许新建重复记录。请改为修改该人才信息。`);
+        }
+        const formId = payload.formId;
+        const objId = payload.objId;
+        if (!formId || !objId || !Array.isArray(payload.dataDetails)) {
+            throw ehrValidationError('continuation_payload_invalid', 'continuation 缺少表单参数（formId/objId/dataDetails），请重新执行 prepare');
+        }
+        const session = await env.host.getSession();
+        const appId = (await requireRecruitCache(env)).appId;
+        const customParam = {
+            objId,
+            name,
+            firstDataName: name,
+            isFlowEnd: false,
+            otherOperator: '',
+            dataStatus: 'submit',
+            rightType: '0',
+            appId,
+        };
+        const formData = {
+            module: 'ebuilderform',
+            client: 'pc',
+            dataStatus: 'submit',
+            form: { id: formId },
+            formLayout: { id: formId },
+            dataDetails: payload.dataDetails,
+        };
+        let saveResponse;
+        try {
+            saveResponse = (await env.host.request({
+                path: `/api/ebuilder/form/form/core/saveFormData?formId=${formId}`,
+                body: { module: 'ebuilderform', appId, customParam, formData },
+            }));
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('saveFormData 请求发送后连接中断，是否创建成功不确定，禁止自动重试；请用 candidate.search 按手机号回查确认', { attempted: { name, mobile } }, { stage: 'candidate.create.save' });
+            }
+            throw error;
+        }
+        if (!saveResponse?.status && saveResponse?.code !== 200) {
+            throw ehrValidationError('save_failed', `saveFormData 失败: ${saveResponse?.msg || JSON.stringify(saveResponse).slice(0, 200)}`);
+        }
+        const newId = saveResponse?.data?.id;
+        if (!newId) {
+            throw ehrPartialError('saveFormData 未返回新记录 id，创建结果不确定，禁止自动重试；请用 candidate.search 回查确认', { attempted: { name, mobile } }, { stage: 'candidate.create.save' });
+        }
+        // 第二步：初始化人才批次（失败不影响记录已创建，但必须如实报告 partial）
+        let initMsg = '';
+        let initOk = true;
+        try {
+            const initResponse = (await env.host.request({
+                path: `/api/recruit/candidate/initTalentBatch?formDataId=${newId}`,
+                method: 'POST',
+            }));
+            initMsg = initResponse?.data?.msg || initResponse?.msg || '';
+        }
+        catch (error) {
+            initOk = false;
+            initMsg = error instanceof Error ? error.message : String(error);
+        }
+        if (!initOk) {
+            throw ehrPartialError(`人才记录已创建（talentId=${newId}），但 initTalentBatch 初始化批次失败：${initMsg}。请人工在 E10 中确认批次状态，禁止自动重试。`, { talentId: newId, initTalentBatchError: initMsg }, { stage: 'candidate.create.init' });
+        }
+        return ehrSuccess('ehr.recruit.candidate.create.apply', {
+            status: 'COMPLETE',
+            talentId: newId,
+            initTalentBatch: initMsg,
+            searchHint: `可用 ehr.recruit.candidate.search 按 name=${name} 或 mobile=${mobile} 回查`,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 安排面试 operation
+// ---------------------------------------------------------------------------
+const INTERVIEW_TYPES = ['现场面试', '视频面试', '电话面试', 'AI面试'];
+const INTERVIEW_DATAKEYS = ['subject', 'start_time', 'end_time', 'interview_type', 'interview_session', 'interviewer',
+    'position_manage_id', 'talent_id', 'candidate_manage_id', 'mobile', 'email', 'interview_location', 'notice_mould'];
+function defaultInterviewWindow() {
+    const pad = (n) => String(n).padStart(2, '0');
+    const now = new Date();
+    const fmt = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+    const end = new Date(now.getTime() + 60 * 60 * 1000);
+    return { start: fmt(now), end: fmt(end) };
+}
+async function buildInterviewPlan(env, cache, args) {
+    const host = env.host;
+    const talentId = requiredString(args, 'talentId', 'talent_id_required', '人才 ID');
+    if (!/^\d+$/.test(talentId))
+        throw ehrValidationError('talent_id_invalid', 'talentId 必须是数字 ID');
+    const interviewer = requiredString(args, 'interviewer', 'interviewer_required', '面试官姓名');
+    const type = typeof args.type === 'string' && args.type.trim() ? args.type.trim() : '现场面试';
+    if (!INTERVIEW_TYPES.includes(type)) {
+        throw ehrValidationError('enum_invalid', `type（面试方式）取值必须是 ${INTERVIEW_TYPES.join(' / ')} 之一`);
+    }
+    const session = typeof args.session === 'string' && args.session.trim() ? args.session.trim() : '初试';
+    const candidate = await resolveCandidateForWrite(host, cache, talentId);
+    const positionId = args.positionId ? String(args.positionId) : candidate.positionId;
+    if (!positionId) {
+        throw ehrValidationError('position_not_resolved', '未定位到应聘职位（positionId），请提供 positionId 参数');
+    }
+    if (!candidate.candidateManageId) {
+        throw ehrValidationError('candidate_manage_missing', '未定位到应聘管理记录（candidateManageId），请确认该人才已有应聘批次');
+    }
+    const objId = cacheObjId(cache, 'interview_plan', '面试计划表单');
+    const formId = cacheFormId(cache, 'interview_plan');
+    const fields = cache.fields[objId] || {};
+    const portalFields = await getInterviewPortalFieldIds(host);
+    const fieldIdOf = (key) => fields[key] || portalFields[key] || '';
+    for (const key of INTERVIEW_DATAKEYS) {
+        if (!fieldIdOf(key)) {
+            throw ehrValidationError('recruit_field_missing', `面试计划表单缺少字段 ${key}（ds/fields 与门户字段均解析不到）`);
+        }
+    }
+    const typeMap = await getDsOptions(host, objId, fieldIdOf('interview_type'), cache.appId);
+    const typeOptionId = typeMap[type];
+    if (!typeOptionId) {
+        throw ehrValidationError('enum_invalid', `面试方式「${type}」不在枚举中（${Object.keys(typeMap).join(' / ')}）`);
+    }
+    const sessionMap = await getDsOptions(host, objId, fieldIdOf('interview_session'), cache.appId);
+    const sessionOptionId = sessionMap[session];
+    if (!sessionOptionId) {
+        throw ehrValidationError('enum_invalid', `面试轮次「${session}」不在枚举中（${Object.keys(sessionMap).join(' / ')}）`);
+    }
+    const interviewerId = await resolvePersonId(host, fieldIdOf('interviewer'), interviewer);
+    if (!interviewerId) {
+        throw ehrValidationError('interviewer_not_found', `面试官「${interviewer}」解析不到 userId（browser/complete/resource 无匹配）`);
+    }
+    const window = defaultInterviewWindow();
+    const start = typeof args.startTime === 'string' && args.startTime.trim() ? args.startTime.trim() : window.start;
+    const end = typeof args.endTime === 'string' && args.endTime.trim() ? args.endTime.trim() : window.end;
+    if (!/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(start) || !/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(end)) {
+        throw ehrValidationError('time_format_invalid', 'startTime/endTime 格式必须是 YYYY-MM-DD HH:mm');
+    }
+    const subject = (candidate.positionName ? `${candidate.positionName}-` : '') + candidate.name + '的面试';
+    const dataDetails = [
+        { formField: { id: fieldIdOf('subject') }, content: subject },
+        { formField: { id: fieldIdOf('start_time') }, content: start },
+        { formField: { id: fieldIdOf('end_time') }, content: end },
+        { formField: { id: fieldIdOf('interview_type') }, dataOptions: [{ optionId: typeOptionId, content: type }] },
+        { formField: { id: fieldIdOf('interview_session') }, dataOptions: [{ optionId: sessionOptionId, content: session }] },
+        { formField: { id: fieldIdOf('interviewer') }, dataOptions: [{ optionId: interviewerId, content: interviewer }] },
+        { formField: { id: fieldIdOf('position_manage_id') }, dataOptions: [{ optionId: positionId, content: candidate.positionName }] },
+        { formField: { id: fieldIdOf('talent_id') }, dataOptions: [{ optionId: talentId, content: candidate.name }] },
+        { formField: { id: fieldIdOf('candidate_manage_id') }, dataOptions: [{ optionId: candidate.candidateManageId, content: candidate.candidateManageId }] },
+    ];
+    return {
+        formId, objId, dataDetails,
+        candidateName: candidate.name,
+        positionName: candidate.positionName,
+        interviewTime: `${start} ~ ${end}`,
+        interviewer,
+    };
+}
+const interviewArrangeSchema = {
+    talentId: { type: 'string', pattern: '^\\d+$', description: '人才 ID（candidate.search 返回的 talentId）' },
+    interviewer: { type: 'string', description: '面试官姓名（须可解析为系统人员）' },
+    type: { type: 'string', enum: [...INTERVIEW_TYPES], description: '面试方式，默认现场面试' },
+    session: { type: 'string', description: '面试轮次（如 初试/复试），默认初试；须在枚举内' },
+    positionId: { type: 'string', description: '应聘职位 ID；不填时从人才当前应聘批次继承' },
+    startTime: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$', description: '开始时间 YYYY-MM-DD HH:mm，默认当前时间' },
+    endTime: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$', description: '结束时间，默认开始时间 +1 小时' },
+    notify: { type: 'boolean', description: '是否触发「新建日程」面试通知动作流（外部通知），默认 false' },
+};
+const interviewArrangePrepare = {
+    name: 'ehr.recruit.candidate.interview.arrange.prepare',
+    resource: 'recruit',
+    method: 'candidate.interview.arrange.prepare',
+    action: 'ehr.recruit.candidate.interview.arrange.prepare',
+    summary: '准备安排面试：候选人定位 + 面试方式/轮次/面试官解析 + 确认摘要，不写入任何数据',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...interviewArrangeSchema }, { required: ['talentId', 'interviewer'] }),
+    handler: async (args, env) => {
+        const cache = await requireRecruitCache(env);
+        const plan = await buildInterviewPlan(env, cache, args);
+        const session = await env.host.getSession();
+        const notify = args.notify === true;
+        const payload = { ...args, formId: plan.formId, objId: plan.objId, dataDetails: plan.dataDetails, notify };
+        const token = await env.continuation.issue({
+            operation: 'ehr.recruit.candidate.interview.arrange.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload,
+            fingerprint: fingerprint({ dataDetails: plan.dataDetails, notify }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return ehrSuccess('ehr.recruit.candidate.interview.arrange.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                action: '安排面试',
+                candidate: `${plan.candidateName}（talentId=${args.talentId}）`,
+                position: plan.positionName || '(未解析到)',
+                type: args.type || '现场面试',
+                session: args.session || '初试',
+                time: plan.interviewTime,
+                interviewer: plan.interviewer,
+                notify: notify ? '将触发「新建日程」面试通知动作流（外部通知）' : '面试通知默认不触发',
+            },
+            willSubmit: { formId: plan.formId, objId: plan.objId, dataDetails: plan.dataDetails },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const interviewArrangeApply = {
+    name: 'ehr.recruit.candidate.interview.arrange.apply',
+    resource: 'recruit',
+    method: 'candidate.interview.arrange.apply',
+    action: 'ehr.recruit.candidate.interview.arrange.apply',
+    summary: '执行安排面试（saveFormData 面试计划 → assignedInterview 分配；notify=true 时先触发通知动作流）；必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...interviewArrangeSchema, confirm: { const: true }, continuation: { type: 'string', minLength: 1 } }, { required: ['talentId', 'interviewer', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.candidate.interview.arrange.apply');
+        const lease = await verifyLease(args, 'ehr.recruit.candidate.interview.arrange.apply', env);
+        const payload = (lease.payload || {});
+        const cache = await requireRecruitCache(env);
+        const plan = await buildInterviewPlan(env, cache, args);
+        if (fingerprint({ dataDetails: plan.dataDetails, notify: args.notify === true }) !== lease.fingerprint) {
+            throw ehrValidationError('target_changed', '输入与 prepare 时的快照不一致（候选人/面试官/时间等被修改），请重新执行 prepare');
+        }
+        const formId = payload.formId || plan.formId;
+        const objId = payload.objId || plan.objId;
+        const notify = args.notify === true;
+        // ② 面试通知动作流（外部通知，仅在 notify=true 时触发）
+        let notifyResult = null;
+        if (notify) {
+            const actions = await getFormActions(env.host, objId);
+            const esbId = pickEsbActionId(actions, ['新建日程']);
+            if (!esbId)
+                requireEsbActionId(objId, ['新建日程']);
+        }
+        // ① 新建面试计划
+        let planFormId;
+        try {
+            planFormId = await saveFormData(env.host, {
+                appId: cache.appId, formId, objId,
+                name: `面试管理-${plan.candidateName} ${plan.interviewTime}`,
+                dataDetails: plan.dataDetails,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('saveFormData 请求发送后连接中断，面试计划是否创建不确定，禁止自动重试；请用 candidate.card 回查确认', { attempted: { talentId: args.talentId } }, { stage: 'interview.arrange.save' });
+            }
+            throw error;
+        }
+        if (!planFormId) {
+            throw ehrPartialError('saveFormData 未返回面试计划记录 id，创建结果不确定，禁止自动重试', { attempted: { talentId: args.talentId } }, { stage: 'interview.arrange.save' });
+        }
+        if (notify) {
+            const actions = await getFormActions(env.host, objId);
+            const esbId = pickEsbActionId(actions, ['新建日程']);
+            if (esbId)
+                notifyResult = await runEsb(env.host, objId, planFormId, esbId);
+        }
+        // ③ 分配面试（失败不影响计划已创建 → partial 如实报告）
+        let assigned;
+        try {
+            assigned = (await env.host.request({
+                path: `/api/recruit/candidate/assignedInterview?formDataId=${planFormId}`,
+                method: 'POST',
+            }));
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError(`面试计划已创建（id=${planFormId}），但 assignedInterview 请求连接中断，分配结果不确定，禁止自动重试；请人工在 E10 面试管理确认`, { interviewFormId: planFormId }, { stage: 'interview.arrange.assign' });
+            }
+            throw error;
+        }
+        return ehrSuccess('ehr.recruit.candidate.interview.arrange.apply', {
+            status: 'COMPLETE',
+            interviewFormId: planFormId,
+            notify: notifyResult,
+            assigned: assigned?.data || {},
+            candidate: `${plan.candidateName}（talentId=${args.talentId}）`,
+            time: plan.interviewTime,
+            interviewer: plan.interviewer,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 发送 Offer 邮件 operation（L3 外部通知，四步：estValidateOffer → saveFormData → sendOffer → runEsb）
+// 迁移自 ehr 技能 recruit-send-offer.mjs。
+// ---------------------------------------------------------------------------
+async function locateOfferRow(host, cache, talentId) {
+    const offerList = cache.lists.offer;
+    if (!offerList?.listId) {
+        throw ehrValidationError('recruit_list_unavailable', '当前环境未启用「录用管理」（Offer 管理）功能菜单');
+    }
+    const offerObjId = cacheObjId(cache, 'offer', '录用管理');
+    const body = writeListBody({
+        listId: offerList.listId, cusMenuId: offerList.cusMenuId,
+        menuName: offerList.menuName || '录用管理', title: '录用管理', pageSize: 50,
+    });
+    const response = (await host.request({
+        path: `/api/ebuilder/form/list/getListDatas?passid=${offerObjId}&cid=${offerObjId}`,
+        body,
+        headers: { ebBusinessId: offerList.listId },
+    }));
+    const rows = response?.data?.data || [];
+    const row = rows.find((item) => String(item.talentId) === String(talentId));
+    if (!row) {
+        throw ehrValidationError('offer_not_found', `未在 Offer 管理列表找到 talentId=${talentId} 的 Offer 记录（offer 流程可能未走完，无法发 Offer）`);
+    }
+    if (!row.offer_id) {
+        throw ehrValidationError('offer_id_missing', '该候选人 Offer 记录缺少 offer_id，无法发送（offer 流程可能未走完）');
+    }
+    const status = Array.isArray(row.offer_status_select)
+        ? (row.offer_status_select[0]?.name || '')
+        : String(row.offer_status_select || '');
+    return { ...row, __status: status };
+}
+async function resolveOfferTemplate(host, cache, templateName) {
+    const response = (await host.request({
+        path: '/api/ebuilder/form/obj/getObjsByTag',
+        query: { appId: cache.appId, tag: 'uf_rcrt_notify_mould' },
+    }));
+    const mouldObjId = Array.isArray(response?.data) && response.data.length ? String(response.data[0].id) : '';
+    if (!mouldObjId) {
+        throw ehrValidationError('template_form_missing', '当前环境未取到邮件通知模板表单（uf_rcrt_notify_mould），无法解析 Offer 邮件模板');
+    }
+    const allData = (await host.request({
+        path: '/api/ebuilder/form/dataset/v2/getAllData',
+        body: { datajson: { header: { objId: mouldObjId }, mainTable: {}, pageInfo: { pageNo: 1, pageSize: 200 } } },
+    }));
+    const datas = allData?.data?.datajson?.datas || [];
+    const hit = datas.find((item) => {
+        const main = item.mainTable || {};
+        const name = main.mould_name?.fieldValue || '';
+        const type = Array.isArray(main.mould_type) ? (main.mould_type[0]?.fieldOptionName || '') : '';
+        return name === templateName && (type === '发送offer' || type === '');
+    });
+    if (!hit) {
+        const names = datas.map((item) => item.mainTable?.mould_name?.fieldValue).filter(Boolean);
+        throw ehrValidationError('template_not_found', `未找到邮件模板「${templateName}」（可选：${names.join('、')}），请确认模板名称`);
+    }
+    return {
+        id: String(hit.mainTable.id.fieldValue),
+        name: templateName,
+        subject: hit.mainTable.email_subject?.fieldValue || '',
+    };
+}
+const offerSendSchema = {
+    talentId: { type: 'string', pattern: '^\\d+$', description: '人才 ID' },
+    email: { type: 'string', description: '收件邮箱；不填时使用 Offer 记录上的邮箱' },
+    deadline: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$', description: 'Offer 失效日期 YYYY-MM-DD；不填时使用 Offer 记录的入职时间' },
+    days: { type: 'integer', minimum: 1, description: '确认有效天数，默认 5' },
+    template: { type: 'string', description: '邮件模板名称（uf_rcrt_notify_mould 表 mould_name），默认 offer通知' },
+};
+async function buildOfferPlan(env, cache, args) {
+    const host = env.host;
+    const talentId = requiredString(args, 'talentId', 'talent_id_required', '人才 ID');
+    if (!/^\d+$/.test(talentId))
+        throw ehrValidationError('talent_id_invalid', 'talentId 必须是数字 ID');
+    const row = await locateOfferRow(host, cache, talentId);
+    if (row.__status !== '未发送') {
+        throw ehrValidationError('offer_status_invalid', `该 Offer 当前状态为「${row.__status}」，不是「未发送」——再次发送会重复打扰候选人，请先向用户说明并获确认后再继续`);
+    }
+    const toEmail = typeof args.email === 'string' && args.email.trim() ? args.email.trim() : String(row.email || '');
+    if (!toEmail) {
+        throw ehrValidationError('email_required', 'Offer 记录无收件邮箱且对话未提供 email，无法发送（邮箱必填）');
+    }
+    const templateName = typeof args.template === 'string' && args.template.trim() ? args.template.trim() : 'offer通知';
+    const template = await resolveOfferTemplate(host, cache, templateName);
+    const deadline = typeof args.deadline === 'string' && args.deadline.trim() ? args.deadline.trim() : String(row.entry_time || '');
+    if (!deadline) {
+        throw ehrValidationError('deadline_required', '未提供 offer 失效日期（deadline YYYY-MM-DD），无法发送');
+    }
+    const days = typeof args.days === 'number' && Number.isFinite(args.days) ? Math.floor(args.days) : 5;
+    const fbObjId = cacheObjId(cache, 'offer_sending', 'offer反馈表单');
+    const fbFormId = cacheFormId(cache, 'offer_sending');
+    const fields = cache.fields[fbObjId] || {};
+    for (const key of ['talent_name', 'email', 'phone', 'offer_mod_id', 'offer_exp_date', 'send_msg', 'offer_id', 'exp_days', 'can_edit_exp']) {
+        if (!fields[key]) {
+            throw ehrValidationError('recruit_field_missing', `offer反馈 表单缺少字段映射 ${key}（环境缓存未含该表单字段）`);
+        }
+    }
+    // getDataName：取 Offer 记录标题（关联字段 content 用）
+    let offerName = 'Offer';
+    try {
+        const nameResponse = (await host.request({
+            path: '/api/ebuilder/form/data/getDataName',
+            body: { id: String(row.offer_id), objId: cacheObjId(cache, 'offer', '录用管理') },
+        }));
+        offerName = nameResponse?.data?.dataInfo?.dataName || 'Offer';
+    }
+    catch { /* 回退 'Offer' */ }
+    const dataDetails = [
+        { formField: { id: fields.talent_name }, content: row.candidate_name },
+        { formField: { id: fields.email }, content: toEmail },
+        { formField: { id: fields.send_msg }, dataOptions: [{ optionId: '0', content: '关闭' }] },
+        { formField: { id: fields.exp_days }, content: String(days) },
+        { formField: { id: fields.can_edit_exp }, dataOptions: [{ optionId: '0', content: '不可编辑' }] },
+        { formField: { id: fields.offer_exp_date }, content: deadline },
+        { formField: { id: fields.offer_mod_id }, dataOptions: [{ optionId: template.id, content: template.name }] },
+        { formField: { id: fields.offer_id }, dataOptions: [{ optionId: String(row.offer_id), content: offerName }] },
+    ];
+    return {
+        fbObjId, fbFormId, dataDetails,
+        offerId: String(row.offer_id), offerName, toEmail, deadline, days,
+        templateName, candidateName: String(row.candidate_name || row.name || ''),
+    };
+}
+const offerSendPrepare = {
+    name: 'ehr.recruit.offer.send.prepare',
+    resource: 'recruit',
+    method: 'offer.send.prepare',
+    action: 'ehr.recruit.offer.send.prepare',
+    summary: '准备发送 Offer 邮件（L3 外部通知）：Offer 定位 + 状态/邮箱/模板/失效日期校验 + 确认摘要，不写入不发送',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...offerSendSchema }, { required: ['talentId'] }),
+    handler: async (args, env) => {
+        const cache = await requireRecruitCache(env);
+        const plan = await buildOfferPlan(env, cache, args);
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'ehr.recruit.offer.send.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: { ...args, fbObjId: plan.fbObjId, fbFormId: plan.fbFormId, dataDetails: plan.dataDetails, offerId: plan.offerId },
+            fingerprint: fingerprint({ dataDetails: plan.dataDetails, offerId: plan.offerId }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return ehrSuccess('ehr.recruit.offer.send.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                action: '发送 Offer 邮件（L3 外部通知）',
+                candidate: `${plan.candidateName}（talentId=${args.talentId}）`,
+                offerId: plan.offerId,
+                toEmail: plan.toEmail,
+                template: plan.templateName,
+                deadline: plan.deadline,
+                days: plan.days,
+                note: '确认后才执行 estValidateOffer → saveFormData → sendOffer → 动作流四步；邮件会真实发送给候选人',
+            },
+            willSubmit: { formId: plan.fbFormId, objId: plan.fbObjId, dataDetails: plan.dataDetails },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const offerSendApply = {
+    name: 'ehr.recruit.offer.send.apply',
+    resource: 'recruit',
+    method: 'offer.send.apply',
+    action: 'ehr.recruit.offer.send.apply',
+    summary: '执行发送 Offer 邮件（estValidateOffer → 新建 offer反馈 → sendOffer → 动作流）；必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...offerSendSchema, confirm: { const: true }, continuation: { type: 'string', minLength: 1 } }, { required: ['talentId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.offer.send.apply');
+        const lease = await verifyLease(args, 'ehr.recruit.offer.send.apply', env);
+        const payload = (lease.payload || {});
+        if (!payload.fbObjId || !payload.fbFormId || !Array.isArray(payload.dataDetails) || !payload.offerId) {
+            throw ehrValidationError('continuation_payload_invalid', 'continuation 缺少表单参数，请重新执行 prepare');
+        }
+        const cache = await requireRecruitCache(env);
+        // ① 服务端校验（estValidateOffer）
+        let validateResponse;
+        try {
+            validateResponse = (await env.host.request({
+                path: `/api/recruit/estPre/estValidateOffer?offerId=${payload.offerId}`,
+                method: 'POST',
+            }));
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('estValidateOffer 请求连接中断，校验结果不确定，禁止自动重试', { offerId: payload.offerId }, { stage: 'offer.send.validate' });
+            }
+            throw error;
+        }
+        if (validateResponse?.data?.validateSuccess !== true) {
+            throw ehrValidationError('offer_validate_failed', `estValidateOffer 校验未通过：${validateResponse?.msg || '未知原因'}`);
+        }
+        // ② 新建 offer反馈 记录
+        let fbId;
+        try {
+            fbId = await saveFormData(env.host, {
+                appId: cache.appId, formId: payload.fbFormId, objId: payload.fbObjId,
+                name: `offer反馈-${payload.dataDetails[0]?.content || ''} ${new Date().toLocaleString('zh-CN', { hour12: false }).replace(/\//g, '-')}`,
+                dataDetails: payload.dataDetails,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('saveFormData（offer反馈）请求连接中断，是否写入不确定，禁止自动重试；请回查 Offer 状态', { offerId: payload.offerId }, { stage: 'offer.send.save' });
+            }
+            throw error;
+        }
+        if (!fbId) {
+            throw ehrPartialError('新建 offer反馈 记录失败（未返回 id），禁止自动重试', { offerId: payload.offerId }, { stage: 'offer.send.save' });
+        }
+        // ③ 发送
+        let sendResponse;
+        try {
+            sendResponse = (await env.host.request({
+                path: `/api/recruit/offer/sendOffer?formDataId=${fbId}`,
+                method: 'POST',
+            }));
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError(`offer反馈记录已创建（id=${fbId}），但 sendOffer 请求连接中断，邮件是否已发出不确定，禁止自动重试；请回查 offer_status_select`, { feedbackRecordId: fbId }, { stage: 'offer.send.sendOffer' });
+            }
+            throw error;
+        }
+        if (sendResponse?.status !== true) {
+            throw ehrPartialError(`sendOffer 失败：${sendResponse?.msg || JSON.stringify(sendResponse).slice(0, 200)}。offer反馈记录（id=${fbId}）已存在，请人工核对后处理，禁止自动重试`, { feedbackRecordId: fbId }, { stage: 'offer.send.sendOffer' });
+        }
+        // ④ 触发发信动作流
+        const actions = await getFormActions(env.host, payload.fbObjId);
+        const esbId = pickEsbActionId(actions, ['更新offer发送信息']);
+        if (!esbId)
+            requireEsbActionId(payload.fbObjId, ['更新offer发送信息']);
+        const esbResult = await runEsb(env.host, payload.fbObjId, fbId, esbId);
+        return ehrSuccess('ehr.recruit.offer.send.apply', {
+            status: 'COMPLETE',
+            feedbackRecordId: fbId,
+            validateOffer: '通过',
+            sendOffer: 'SUCCESS',
+            runEsb: { successNum: esbResult.successNum, failNum: esbResult.failNum, msg: esbResult.successMsg },
+            nextStep: '回查 offer_status_select 应已变更为「已发送待反馈」',
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 办理入职 operation（路径 B：对已有待入职记录办理；落账号不可逆）
+// 迁移自 ehr 技能 recruit-process-entry.mjs。
+// ---------------------------------------------------------------------------
+async function inheritFromOffer(host, cache, talentId) {
+    const out = {};
+    const offerList = cache.lists.offer;
+    if (!offerList?.listId)
+        return out;
+    const offerObjId = cache.forms.offer?.objId;
+    if (!offerObjId)
+        return out;
+    const body = writeListBody({
+        listId: offerList.listId, cusMenuId: offerList.cusMenuId,
+        menuName: offerList.menuName || '录用管理', title: '录用管理', pageSize: 100,
+    });
+    const response = (await host.request({
+        path: `/api/ebuilder/form/list/getListDatas?passid=${offerObjId}&cid=${offerObjId}`,
+        body,
+        headers: { ebBusinessId: offerList.listId },
+    }));
+    const row = (response?.data?.data || []).find((item) => String(item.talentId) === String(talentId));
+    if (!row)
+        return out;
+    const sub = Array.isArray(row.subcompany) ? row.subcompany[0]?.id : (row.subcompany_id || row.subcompany);
+    const pos = row.position_id || (Array.isArray(row.position) ? row.position[0]?.id : row.position);
+    if (sub)
+        out.subcompany = String(sub);
+    if (pos)
+        out.position = String(pos);
+    if (row.entry_time)
+        out.entryTime = String(row.entry_time);
+    if (row.telephone)
+        out.phone = String(row.telephone);
+    return out;
+}
+async function locateEntryRow(host, cache, talentId, entryIdArg) {
+    const entryList = cache.lists.entry;
+    if (!entryList?.listId) {
+        throw ehrValidationError('recruit_list_unavailable', '当前环境未启用「入职管理」功能菜单');
+    }
+    const entryObjId = cacheObjId(cache, 'entry_manage', '入职管理');
+    const inherited = await inheritFromOffer(host, cache, talentId);
+    const phone = inherited.phone;
+    const body = writeListBody({
+        listId: entryList.listId, cusMenuId: entryList.cusMenuId,
+        menuName: entryList.menuName || '入职管理', title: '入职管理', pageSize: 100,
+    });
+    const response = (await host.request({
+        path: `/api/ebuilder/form/list/getListDatas?passid=${entryObjId}&cid=${entryObjId}`,
+        body,
+        headers: { ebBusinessId: entryList.listId },
+    }));
+    const rows = response?.data?.data || [];
+    let row = null;
+    if (entryIdArg)
+        row = rows.find((item) => String(item.form_data_id || item.id) === String(entryIdArg));
+    if (!row && phone)
+        row = rows.find((item) => String(item.telephone) === String(phone));
+    if (!row) {
+        throw ehrValidationError('entry_not_found', `未在入职管理列表定位到入职记录（entryId=${entryIdArg || '—'} / 手机=${phone || '—'}），请确认该候选人已有待入职记录`);
+    }
+    const entryId = String(row.form_data_id || row.id || '');
+    if (!entryId)
+        throw ehrValidationError('entry_id_missing', '入职记录缺少 form_data_id，无法办理');
+    // transact_status：1=待办理 2=已办理
+    const ts = Array.isArray(row.transact_status) ? (row.transact_status[0]?.name || '') : String(row.transact_status || '').replace(/"/g, '');
+    return { entryId, name: String(row.xm || row.name || ''), transactStatus: ts };
+}
+const entryProcessSchema = {
+    talentId: { type: 'string', pattern: '^\\d+$', description: '人才 ID' },
+    entryId: { type: 'string', description: '入职记录 ID；不填时按 Offer 记录手机号在入职列表匹配' },
+    subcompanyId: { type: 'string', description: '入职分部 ID；不填时从 Offer 记录继承' },
+    departmentId: { type: 'string', description: '入职部门 ID（必填，Offer 记录无此字段）' },
+    positionId: { type: 'string', description: '入职职位 ID；不填时从 Offer 记录继承' },
+    positionRankId: { type: 'string', description: '职级 ID（必填）' },
+    entryTime: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$', description: '入职日期 YYYY-MM-DD；不填时从 Offer 记录继承' },
+};
+async function buildEntryPlan(env, cache, args) {
+    const host = env.host;
+    const talentId = requiredString(args, 'talentId', 'talent_id_required', '人才 ID');
+    if (!/^\d+$/.test(talentId))
+        throw ehrValidationError('talent_id_invalid', 'talentId 必须是数字 ID');
+    const department = requiredString(args, 'departmentId', 'department_required', '入职部门 ID');
+    const positionRank = requiredString(args, 'positionRankId', 'position_rank_required', '职级 ID');
+    const entry = await locateEntryRow(host, cache, talentId, typeof args.entryId === 'string' ? args.entryId.trim() : '');
+    if (entry.transactStatus === '2') {
+        throw ehrValidationError('entry_already_processed', '该入职记录已办理（transact_status=2），无需重复办理');
+    }
+    const inherited = await inheritFromOffer(host, cache, talentId);
+    const subcompany = (typeof args.subcompanyId === 'string' && args.subcompanyId.trim()) || inherited.subcompany || '';
+    const position = (typeof args.positionId === 'string' && args.positionId.trim()) || inherited.position || '';
+    const entryTime = (typeof args.entryTime === 'string' && args.entryTime.trim()) || inherited.entryTime || '';
+    if (!subcompany)
+        throw ehrValidationError('subcompany_required', '缺少入职分部 subcompanyId（Offer 记录亦无，请显式提供）');
+    if (!position)
+        throw ehrValidationError('position_required', '缺少入职职位 positionId（Offer 记录亦无，请显式提供）');
+    if (!entryTime)
+        throw ehrValidationError('entry_time_required', '缺少入职日期 entryTime（YYYY-MM-DD，Offer 记录亦无）');
+    // ① 服务端校验（estValidateEntry，带 entryId 路径 B）
+    const query = `subcompany=${subcompany}&department=${department}&position=${position}&positionRank=${positionRank}&entryTime=${entryTime}&entryId=${entry.entryId}`;
+    const validateResponse = (await host.request({
+        path: `/api/recruit/estPre/estValidateEntry?${query}`,
+        method: 'POST',
+    }));
+    if (validateResponse?.data?.validateSuccess !== true) {
+        throw ehrValidationError('entry_validate_failed', `estValidateEntry 校验未通过：${validateResponse?.msg || '组织架构组合有误'}`);
+    }
+    // 读取表单现状（updateTimeStamp 乐观锁 / 编辑布局 / 现有字段值）
+    const emObjId = cacheObjId(cache, 'entry_manage', '入职管理');
+    const emFormId = cacheFormId(cache, 'entry_manage');
+    const fields = cache.fields[emObjId] || {};
+    for (const key of ['xm', 'telephone', 'email', 'subcompany', 'department', 'position', 'position_rank', 'entry_time', 'entry_status', 'info_collection']) {
+        if (!fields[key])
+            throw ehrValidationError('recruit_field_missing', `入职管理表单缺少字段映射 ${key}`);
+    }
+    const record = await getFormDataRecord(host, emFormId, entry.entryId, emObjId);
+    if (!record.updateTimeStamp) {
+        throw ehrValidationError('update_timestamp_missing', '未取到入职记录 updateTimeStamp（乐观锁），无法更新');
+    }
+    if (!record.formLayoutId) {
+        throw ehrValidationError('edit_layout_missing', '未取到编辑布局 id，无法更新入职记录');
+    }
+    const existing = toSubmitDetails(record.dataDetails);
+    const setField = (fieldId, detail) => {
+        const index = existing.findIndex((item) => item.formField?.id === fieldId);
+        if (index >= 0)
+            existing[index] = detail;
+        else
+            existing.push(detail);
+    };
+    setField(fields.subcompany, { formField: { id: fields.subcompany }, dataOptions: [{ optionId: subcompany, content: '入职分部' }] });
+    setField(fields.department, { formField: { id: fields.department }, dataOptions: [{ optionId: department, content: '入职部门' }] });
+    setField(fields.position, { formField: { id: fields.position }, dataOptions: [{ optionId: position, content: '入职职位' }] });
+    setField(fields.position_rank, { formField: { id: fields.position_rank }, dataOptions: [{ optionId: positionRank, content: '职级' }] });
+    setField(fields.entry_time, { formField: { id: fields.entry_time }, content: entryTime });
+    return {
+        entryId: entry.entryId, candidateName: entry.name, transactStatus: entry.transactStatus,
+        subcompany, department, position, positionRank, entryTime,
+        updateTimeStamp: record.updateTimeStamp, editLayoutId: record.formLayoutId,
+        emObjId, emFormId, dataDetails: existing,
+    };
+}
+const entryProcessPrepare = {
+    name: 'ehr.recruit.entry.process.prepare',
+    resource: 'recruit',
+    method: 'entry.process.prepare',
+    action: 'ehr.recruit.entry.process.prepare',
+    summary: '准备办理入职（路径 B，落账号不可逆）：入职记录定位 + estValidateEntry 校验 + 组织架构确认摘要，不写入',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...entryProcessSchema }, { required: ['talentId', 'departmentId', 'positionRankId'] }),
+    handler: async (args, env) => {
+        const cache = await requireRecruitCache(env);
+        const plan = await buildEntryPlan(env, cache, args);
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'ehr.recruit.entry.process.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: {
+                entryId: plan.entryId, updateTimeStamp: plan.updateTimeStamp, editLayoutId: plan.editLayoutId,
+                emObjId: plan.emObjId, emFormId: plan.emFormId, dataDetails: plan.dataDetails,
+                candidateName: plan.candidateName,
+            },
+            fingerprint: fingerprint({ entryId: plan.entryId, dataDetails: plan.dataDetails }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return ehrSuccess('ehr.recruit.entry.process.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                action: '办理入职（路径 B：对已有待入职记录）',
+                candidate: `${plan.candidateName}（talentId=${args.talentId}）`,
+                entryId: plan.entryId,
+                transactStatus: plan.transactStatus || '待办理',
+                subcompany: plan.subcompany,
+                department: plan.department,
+                position: plan.position,
+                positionRank: plan.positionRank,
+                entryTime: plan.entryTime,
+                note: '提交后更新入职记录 → saveEstPreEntry 落人员账号（不可撤销）→ 触发「offer转入职」动作流；确认后才执行',
+            },
+            willSubmit: { formId: plan.emFormId, objId: plan.emObjId, updateTimeStamp: plan.updateTimeStamp, dataDetails: plan.dataDetails },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const entryProcessApply = {
+    name: 'ehr.recruit.entry.process.apply',
+    resource: 'recruit',
+    method: 'entry.process.apply',
+    action: 'ehr.recruit.entry.process.apply',
+    summary: '执行办理入职（更新入职记录 → saveEstPreEntry 落账号 → 动作流）；落账号不可撤销，必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...entryProcessSchema, confirm: { const: true }, continuation: { type: 'string', minLength: 1 } }, { required: ['talentId', 'departmentId', 'positionRankId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.entry.process.apply');
+        const lease = await verifyLease(args, 'ehr.recruit.entry.process.apply', env);
+        const payload = (lease.payload || {});
+        if (!payload.entryId || !payload.updateTimeStamp || !payload.emObjId || !payload.emFormId || !Array.isArray(payload.dataDetails)) {
+            throw ehrValidationError('continuation_payload_invalid', 'continuation 缺少入职记录参数，请重新执行 prepare');
+        }
+        const cache = await requireRecruitCache(env);
+        // ③ 更新入职记录（rightType=2，带 id + updateTimeStamp + 编辑布局）
+        let saveResponse;
+        try {
+            saveResponse = (await env.host.request({
+                path: `/api/ebuilder/form/form/core/saveFormData?formId=${payload.emFormId}`,
+                body: {
+                    module: 'ebuilderform',
+                    appId: cache.appId,
+                    customParam: {
+                        secretLevel: '', secretLevelValidity: '',
+                        objId: payload.emObjId,
+                        name: `入职管理-${payload.candidateName || ''}`,
+                        firstDataName: `入职管理-${payload.candidateName || ''}`,
+                        isFlowEnd: false, otherOperator: '', dataStatus: 'submit', rightType: '2', appId: cache.appId,
+                    },
+                    formData: {
+                        id: payload.entryId,
+                        updateTimeStamp: payload.updateTimeStamp,
+                        module: 'ebuilderform',
+                        dataDelRows: [],
+                        dataDetails: payload.dataDetails,
+                        form: { id: payload.emFormId },
+                        formLayout: { id: payload.editLayoutId },
+                        client: 'pc',
+                        dataStatus: 'submit',
+                    },
+                },
+            }));
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('saveFormData（入职更新）请求连接中断，更新是否生效不确定，禁止自动重试；请回查入职记录', { entryId: payload.entryId }, { stage: 'entry.process.save' });
+            }
+            throw error;
+        }
+        if (!(saveResponse?.status === true && saveResponse?.code === 200)) {
+            throw ehrValidationError('entry_save_failed', `更新入职记录失败：${saveResponse?.msg || JSON.stringify(saveResponse).slice(0, 200)}`);
+        }
+        // ④ 落账号（不可逆；以 code=200 && status=true && fail=false 为准）
+        let entryAccountResponse;
+        try {
+            entryAccountResponse = (await env.host.request({
+                path: `/api/recruit/estPre/saveEstPreEntry?entryId=${payload.entryId}`,
+                method: 'POST',
+            }));
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError(`入职记录已更新（entryId=${payload.entryId}），但 saveEstPreEntry（落账号）请求连接中断，账号是否已落不确定，禁止自动重试；请人工在 E10 人事模块核对`, { entryId: payload.entryId }, { stage: 'entry.process.account' });
+            }
+            throw error;
+        }
+        if (!(entryAccountResponse?.status === true && entryAccountResponse?.fail === false)) {
+            throw ehrPartialError(`saveEstPreEntry（落账号）失败：${entryAccountResponse?.msg || '未知'}。入职记录已更新但账号未落，请人工核对，禁止自动重试`, { entryId: payload.entryId }, { stage: 'entry.process.account' });
+        }
+        // ⑤ 触发「offer转入职」动作流
+        const actions = await getFormActions(env.host, payload.emObjId);
+        const esbId = pickEsbActionId(actions, ['offer转入职']);
+        if (!esbId)
+            requireEsbActionId(payload.emObjId, ['offer转入职']);
+        const esbResult = await runEsb(env.host, payload.emObjId, payload.entryId, esbId);
+        return ehrSuccess('ehr.recruit.entry.process.apply', {
+            status: 'COMPLETE',
+            entryId: payload.entryId,
+            validateEntry: '通过',
+            saveFormData: '已更新',
+            saveEstPreEntry: '已落账号',
+            runEsb: { successNum: esbResult.successNum, failNum: esbResult.failNum, msg: esbResult.successMsg },
+            nextStep: '回查入职列表 transact_status 应由 1 变为 2',
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 面试反馈编辑 operation（提交/修改面试反馈，全字段集防清空 + 动作流 + 过程日志）
+// 迁移自 ehr 技能 recruit-edit-interview-feedback.mjs。
+// ---------------------------------------------------------------------------
+const INVALID_INTERVIEW_STATUS_ID = '841052191228968977'; // InterviewStatusEnum.INVALID（已失效不允许编辑反馈）
+async function listInterviewFeedback(host, talentId, batchId) {
+    const response = (await host.request({
+        path: '/api/recruit/candidate/getCandidateCardInterviewInfo',
+        body: { talentId, batchId, current: 1, pageSize: 100 },
+    }));
+    const list = response?.data?.list || [];
+    const out = [];
+    for (let index = 0; index < list.length; index++) {
+        const item = list[index];
+        const feedbacks = item?.interviewFeedBack || [];
+        if (feedbacks.length) {
+            const fb = feedbacks[0];
+            out.push({
+                index,
+                planName: fb.interviewPlanId?.[0]?.name || item.subject || '',
+                interviewer: (fb.interviewer || []).map((x) => x.name).join('、') || '',
+                feedbackId: String(fb.id || fb.formDataId || ''),
+                result: (fb.result || []).map((x) => x.name).join('、') || '',
+                judgement: String(fb.judgement || '').replace(/^<p>|<\/p>$/g, '').trim(),
+                unionStatusId: item.unionStatus?.[0]?.id || '',
+                unionStatusName: item.unionStatus?.[0]?.name || '',
+            });
+        }
+    }
+    return out;
+}
+const feedbackEditSchema = {
+    talentId: { type: 'string', pattern: '^\\d+$', description: '人才 ID' },
+    feedbackId: { type: 'string', description: '反馈记录 ID（最稳定位方式）；不填时按 feedbackIndex 定位' },
+    feedbackIndex: { type: 'integer', minimum: 0, description: '第几场含反馈的面试（默认第 0 场）' },
+    result: { type: 'string', description: '面试结果（通过/不通过/待定），须在枚举内' },
+    comment: { type: 'string', description: '面试评价文字；不填时保留原评价' },
+};
+async function buildFeedbackEditPlan(env, cache, args) {
+    const host = env.host;
+    const talentId = requiredString(args, 'talentId', 'talent_id_required', '人才 ID');
+    if (!/^\d+$/.test(talentId))
+        throw ehrValidationError('talent_id_invalid', 'talentId 必须是数字 ID');
+    if (args.result === undefined && args.comment === undefined) {
+        throw ehrValidationError('feedback_content_required', '请提供 result（面试结果）和/或 comment（评价）至少一项');
+    }
+    const candidate = await resolveCandidateForWrite(host, cache, talentId);
+    const batchId = candidate.batchId;
+    const list = await listInterviewFeedback(host, talentId, batchId);
+    if (!list.length) {
+        throw ehrValidationError('feedback_not_found', '该候选人没有可编辑的面试反馈记录');
+    }
+    let target;
+    if (typeof args.feedbackId === 'string' && args.feedbackId.trim()) {
+        target = list.find((item) => String(item.feedbackId) === args.feedbackId.trim());
+        if (!target) {
+            throw ehrValidationError('feedback_not_found', `未找到反馈记录 id=${args.feedbackId}，可选：${list.map((item) => item.feedbackId).join(',')}`);
+        }
+    }
+    else {
+        const index = typeof args.feedbackIndex === 'number' ? args.feedbackIndex : 0;
+        target = list[index];
+        if (!target)
+            throw ehrValidationError('feedback_index_invalid', `feedbackIndex=${index} 超出范围，共 ${list.length} 场含反馈`);
+    }
+    // 面试状态校验：已失效(INVALID)不允许填写/编辑反馈（与系统按钮条件一致）
+    if (target.unionStatusId === INVALID_INTERVIEW_STATUS_ID) {
+        throw ehrValidationError('interview_invalid_status', `该面试状态为「已失效」，不允许填写/编辑面试反馈。面试=${target.planName}，反馈记录Id=${target.feedbackId}`);
+    }
+    const objId = cacheObjId(cache, 'interview_detail', '面试反馈表单');
+    const formId = cacheFormId(cache, 'interview_detail');
+    const fields = cache.fields[objId] || {};
+    const resultFieldId = fields.result;
+    const judgementFieldId = fields.judgement;
+    if (!resultFieldId || !judgementFieldId) {
+        throw ehrValidationError('recruit_field_missing', '环境缓存缺少面试反馈的 result/judgement 字段映射');
+    }
+    let newResultOptionId = null;
+    let newResultName = String(target.result || '');
+    if (typeof args.result === 'string' && args.result.trim()) {
+        const opts = await getDsOptions(host, objId, resultFieldId, cache.appId);
+        newResultOptionId = opts[args.result.trim()] || null;
+        if (!newResultOptionId) {
+            throw ehrValidationError('result_not_in_enum', `未识别的面试结果「${args.result}」，可选：${Object.keys(opts).join(' / ')}`);
+        }
+        newResultName = args.result.trim();
+    }
+    const newComment = args.comment !== undefined ? String(args.comment) : null;
+    return {
+        talentId, batchId, feedbackId: String(target.feedbackId), planName: String(target.planName || ''),
+        interviewer: String(target.interviewer || ''),
+        currentResult: String(target.result || ''), currentJudgement: String(target.judgement || ''),
+        newResultName, newResultOptionId, newComment,
+        objId, formId, resultFieldId, judgementFieldId,
+    };
+}
+const feedbackEditPrepare = {
+    name: 'ehr.recruit.candidate.interview.feedback.edit.prepare',
+    resource: 'recruit',
+    method: 'candidate.interview.feedback.edit.prepare',
+    action: 'ehr.recruit.candidate.interview.feedback.edit.prepare',
+    summary: '准备提交/修改面试反馈：反馈记录定位 + 已失效状态拦截 + 结果枚举解析 + 前后对照摘要，不写入',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...feedbackEditSchema }, { required: ['talentId'] }),
+    handler: async (args, env) => {
+        const cache = await requireRecruitCache(env);
+        const plan = await buildFeedbackEditPlan(env, cache, args);
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'ehr.recruit.candidate.interview.feedback.edit.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: {
+                talentId: plan.talentId, batchId: plan.batchId, feedbackId: plan.feedbackId,
+                newResultOptionId: plan.newResultOptionId, newResultName: plan.newResultName, newComment: plan.newComment,
+                objId: plan.objId, formId: plan.formId, resultFieldId: plan.resultFieldId, judgementFieldId: plan.judgementFieldId,
+            },
+            fingerprint: fingerprint({
+                feedbackId: plan.feedbackId,
+                result: plan.newResultOptionId,
+                comment: plan.newComment,
+            }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return ehrSuccess('ehr.recruit.candidate.interview.feedback.edit.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                action: '提交/修改面试反馈',
+                talentId: plan.talentId,
+                batchId: plan.batchId,
+                interview: plan.planName,
+                interviewer: plan.interviewer,
+                feedbackId: plan.feedbackId,
+                currentFeedback: `${plan.currentResult ? `结果 ${plan.currentResult}` : ''}${plan.currentJudgement ? `；评价 ${plan.currentJudgement}` : ''}` || '(无)',
+                newFeedback: `${plan.newResultOptionId ? `结果 ${plan.newResultName}` : ''}${plan.newComment !== null ? `；评价 ${plan.newComment}` : ''}` || '(不变)',
+                note: 'apply 将保存反馈表单（全字段集 + 乐观锁）并回查校验',
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const feedbackEditApply = {
+    name: 'ehr.recruit.candidate.interview.feedback.edit.apply',
+    resource: 'recruit',
+    method: 'candidate.interview.feedback.edit.apply',
+    action: 'ehr.recruit.candidate.interview.feedback.edit.apply',
+    summary: '执行提交/修改面试反馈（全字段集保存 + 动作流 + 过程日志 + 回查校验）；必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...feedbackEditSchema, confirm: { const: true }, continuation: { type: 'string', minLength: 1 } }, { required: ['talentId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.candidate.interview.feedback.edit.apply');
+        const lease = await verifyLease(args, 'ehr.recruit.candidate.interview.feedback.edit.apply', env);
+        const payload = (lease.payload || {});
+        if (!payload.feedbackId || !payload.objId || !payload.formId) {
+            throw ehrValidationError('continuation_payload_invalid', 'continuation 缺少反馈记录参数，请重新执行 prepare');
+        }
+        const cache = await requireRecruitCache(env);
+        // 重新取最新记录（updateTimeStamp 乐观锁 + 全字段集防清空）
+        const record = await getFormDataRecord(env.host, payload.formId, payload.feedbackId, payload.objId);
+        if (!record.updateTimeStamp) {
+            throw ehrValidationError('update_timestamp_missing', '未取到反馈记录 updateTimeStamp（乐观锁），无法保存');
+        }
+        const details = toSubmitDetails(record.dataDetails);
+        let newDetails = details.map((item) => {
+            const fieldId = item.formField?.id;
+            if (fieldId === payload.resultFieldId && payload.newResultOptionId) {
+                return { formField: { id: fieldId }, dataOptions: [{ optionId: payload.newResultOptionId, content: payload.newResultName }] };
+            }
+            if (fieldId === payload.judgementFieldId && payload.newComment !== null) {
+                return { formField: { id: fieldId }, dataText: { content: `<p>${payload.newComment || ''}</p>` } };
+            }
+            return item;
+        });
+        if (payload.newResultOptionId && !newDetails.some((item) => item.formField?.id === payload.resultFieldId)) {
+            newDetails.push({ formField: { id: payload.resultFieldId }, dataOptions: [{ optionId: payload.newResultOptionId, content: payload.newResultName }] });
+        }
+        if (payload.newComment !== null && !newDetails.some((item) => item.formField?.id === payload.judgementFieldId)) {
+            newDetails.push({ formField: { id: payload.judgementFieldId }, dataText: { content: `<p>${payload.newComment || ''}</p>` } });
+        }
+        // 保存反馈表单
+        let savedId;
+        try {
+            savedId = await saveFormData(env.host, {
+                appId: cache.appId, formId: payload.formId, objId: payload.objId,
+                name: '面试反馈-' + lease.payload?.planName || '面试反馈',
+                dataDetails: newDetails,
+                rightType: '2',
+                formDataId: payload.feedbackId,
+                updateTimeStamp: record.updateTimeStamp,
+                layoutId: record.formLayoutId,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('saveFormData（面试反馈）请求连接中断，保存是否生效不确定，禁止自动重试；请用 candidate.card 回查反馈', { feedbackId: payload.feedbackId }, { stage: 'feedback.edit.save' });
+            }
+            throw error;
+        }
+        if (!savedId)
+            savedId = payload.feedbackId;
+        // 回查校验
+        const backList = await listInterviewFeedback(env.host, String(payload.talentId), String(payload.batchId));
+        const backFeedback = backList.find((item) => String(item.feedbackId) === String(payload.feedbackId));
+        const changed = Boolean(backFeedback)
+            && (!payload.newResultOptionId || String(backFeedback?.result).includes(String(payload.newResultName)))
+            && (payload.newComment === null || String(backFeedback?.judgement).includes(String(payload.newComment)));
+        return ehrSuccess('ehr.recruit.candidate.interview.feedback.edit.apply', {
+            status: changed ? 'COMPLETE' : 'UNCERTAIN',
+            feedbackId: payload.feedbackId,
+            saved: Boolean(savedId),
+            verify: backFeedback
+                ? { result: backFeedback.result, comment: backFeedback.judgement, changed }
+                : '回查未取到该反馈',
+            ...(changed ? {} : { warning: '回查未确认变更生效，请人工在 E10 中核对面试反馈，禁止自动重试' }),
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 催促面试评价 operation（L3 外部通知：向面试官发系统通知）
+// 迁移自 ehr 技能 recruit-urge-feedback.mjs。
+// ---------------------------------------------------------------------------
+const feedbackUrgeSchema = {
+    talentId: { type: 'string', pattern: '^\\d+$', description: '人才 ID' },
+};
+async function buildFeedbackUrgePlan(env, cache, args) {
+    const host = env.host;
+    const talentId = requiredString(args, 'talentId', 'talent_id_required', '人才 ID');
+    if (!/^\d+$/.test(talentId))
+        throw ehrValidationError('talent_id_invalid', 'talentId 必须是数字 ID');
+    const candidate = await resolveCandidateForWrite(host, cache, talentId);
+    const rk = randomHex6();
+    const extra = cache.lists.talent?.listId ? { ebBusinessId: cache.lists.talent.listId } : {};
+    const interviewResponse = (await host.request({
+        path: '/api/recruit/candidate/getCandidateCardInterviewInfo',
+        body: { talentId, batchId: candidate.batchId, current: 1, pageSize: 100 },
+        headers: extra,
+    }));
+    const list = interviewResponse?.data?.list || [];
+    // 取第一条「待反馈」记录（result 为空），没有则取第一条
+    let target = null;
+    for (const item of list) {
+        for (const feedback of item.interviewFeedBack || []) {
+            if (!feedback.result || !feedback.result.length) {
+                target = { it: item, fb: feedback };
+                break;
+            }
+        }
+        if (target)
+            break;
+    }
+    if (!target && list.length) {
+        const item = list[0];
+        const feedback = (item.interviewFeedBack || [])[0];
+        if (feedback)
+            target = { it: item, fb: feedback };
+    }
+    if (!target) {
+        throw ehrValidationError('feedback_not_found', '未找到该候选人的面试反馈记录，无法催评');
+    }
+    const interviewer = target.fb.updater?.[0]?.name || target.it.interviewer?.[0]?.name || candidate.name;
+    // esb 按钮：面试反馈列表 getListButtons
+    const interviewList = cache.lists.interview;
+    if (!interviewList?.listId) {
+        throw ehrValidationError('recruit_list_unavailable', '当前环境未启用「面试管理」功能菜单，无法解析催评动作流按钮');
+    }
+    const interviewDetailObjId = cacheObjId(cache, 'interview_detail', '面试反馈表单');
+    const actions = await getListActions(host, interviewList.listId, interviewDetailObjId);
+    const esbActionId = pickEsbActionId(actions, ['面试安排催评'], ['批量催评']);
+    if (!esbActionId)
+        requireEsbActionId(interviewDetailObjId, ['面试安排催评'], ['批量催评']);
+    return {
+        talentId, name: candidate.name,
+        subject: String(target.it.subject || ''),
+        interviewer,
+        feedbackRecordId: String(target.fb.id),
+        esbActionId, interviewDetailObjId,
+    };
+}
+const feedbackUrgePrepare = {
+    name: 'ehr.recruit.candidate.interview.feedback.urge.prepare',
+    resource: 'recruit',
+    method: 'candidate.interview.feedback.urge.prepare',
+    action: 'ehr.recruit.candidate.interview.feedback.urge.prepare',
+    summary: '准备催促面试评价（L3 外部通知）：待反馈记录定位 + 催评动作流按钮解析 + 确认摘要，不发送',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...feedbackUrgeSchema }, { required: ['talentId'] }),
+    handler: async (args, env) => {
+        const cache = await requireRecruitCache(env);
+        const plan = await buildFeedbackUrgePlan(env, cache, args);
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'ehr.recruit.candidate.interview.feedback.urge.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: {
+                talentId: plan.talentId, feedbackRecordId: plan.feedbackRecordId,
+                esbActionId: plan.esbActionId, interviewDetailObjId: plan.interviewDetailObjId,
+            },
+            fingerprint: fingerprint({ talentId: plan.talentId, feedbackRecordId: plan.feedbackRecordId }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return ehrSuccess('ehr.recruit.candidate.interview.feedback.urge.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                action: '催促面试评价（外部通知）',
+                talent: `${plan.name}（talentId=${plan.talentId}）`,
+                interview: plan.subject,
+                interviewer: plan.interviewer,
+                feedbackRecordId: plan.feedbackRecordId,
+                note: '确认后将向面试官发送「请填写评价」系统通知（会打扰真人，请确保已经用户同意）',
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const feedbackUrgeApply = {
+    name: 'ehr.recruit.candidate.interview.feedback.urge.apply',
+    resource: 'recruit',
+    method: 'candidate.interview.feedback.urge.apply',
+    action: 'ehr.recruit.candidate.interview.feedback.urge.apply',
+    summary: '执行催促面试评价（runEsb 发送系统通知给面试官，L3 外部通知）；必须先 prepare 并经用户明确确认',
+    capability: 'recruit',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...feedbackUrgeSchema, confirm: { const: true }, continuation: { type: 'string', minLength: 1 } }, { required: ['talentId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'ehr.recruit.candidate.interview.feedback.urge.apply');
+        const lease = await verifyLease(args, 'ehr.recruit.candidate.interview.feedback.urge.apply', env);
+        const payload = (lease.payload || {});
+        if (!payload.feedbackRecordId || !payload.esbActionId || !payload.interviewDetailObjId) {
+            throw ehrValidationError('continuation_payload_invalid', 'continuation 缺少催评参数，请重新执行 prepare');
+        }
+        if (fingerprint({ talentId: payload.talentId, feedbackRecordId: payload.feedbackRecordId })
+            !== lease.fingerprint) {
+            throw ehrValidationError('target_changed', '输入与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        let esbResult;
+        try {
+            esbResult = await runEsb(env.host, payload.interviewDetailObjId, payload.feedbackRecordId, payload.esbActionId);
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw ehrPartialError('runEsb（催评通知）请求连接中断，通知是否已发出不确定，禁止自动重试（重复发送会多次打扰面试官）', { feedbackRecordId: payload.feedbackRecordId }, { stage: 'feedback.urge.runEsb' });
+            }
+            throw error;
+        }
+        return ehrSuccess('ehr.recruit.candidate.interview.feedback.urge.apply', {
+            status: 'COMPLETE',
+            feedbackRecordId: payload.feedbackRecordId,
+            runEsb: { successNum: esbResult.successNum, failNum: esbResult.failNum, msg: esbResult.successMsg },
+        });
+    },
+};
+export const recruitWriteOperations = [
+    candidateCreatePrepare,
+    candidateCreateApply,
+    interviewArrangePrepare,
+    interviewArrangeApply,
+    offerSendPrepare,
+    offerSendApply,
+    entryProcessPrepare,
+    entryProcessApply,
+    feedbackEditPrepare,
+    feedbackEditApply,
+    feedbackUrgePrepare,
+    feedbackUrgeApply,
+];