weaver-work-cli 0.1.39 → 0.1.42

package/dist/shortcuts/recruit-stage/operations/interview-arrange.js

@@ -0,0 +1,722 @@
+/**
+ * recruit-stage.interview.arrange.* —— 安排面试（自 recruit-arrange-interview.mjs 1:1 移植）
+ *
+ * 页面「保存」实际执行的是按钮配置里的一串动作（HAR 实证，跨环境由 getFormButtons 运行时解析）：
+ *   ① 系统保存（saveFormData）→ ② esb（如「面试管理-新建日程」）→ ③ jsCode 调 assignedInterview
+ *   → ④ esb（如「AI面试时发送提醒」）
+ * 本模块按同一顺序逐条执行，不写死任何按钮/动作 id；不认识的脚本动作跳过并在 warnings 明示。
+ *
+ * 三种操作：
+ *   .prepare  只出确认摘要（含将执行的动作清单 + AI 面试候选方案），签发 continuation
+ *   .apply    用户确认后执行（confirm + continuation + 指纹比对；AI 面试方案必填未选时阻断）
+ *   .prefill  不落库：输出「人才卡片 URL + 面试管理列表 URL + jsExpr」；Agent 打开人才卡片 →
+ *             （点「安排面试」打开表单）→ 执行 jsExpr 选中「面试方式=AI面试」→ 触发表单联动 → HR 核对保存
+ *
+ * 定位候选人（三选一，未带 talentId 时生效）：mobile（人才库精确检索，唯一命中自动采用）/
+ * name（多条 → needChoice 输出候选让用户选，绝不自动挑一个）。
+ *
+ * AI 面试（type 含 AI/人工智能）时，邮箱与 AI 面试方案（digital_id）均为必填：
+ * 未指定方案时 prepare 输出 aiPlans 候选清单（关联字段候选接口 → 「面试数字人配置」列表兜底，
+ * objId 走 tag、listId 走菜单，均运行时解析），apply 直接阻断；绝不自动取第一条。
+ */
+import { randomUUID } from 'node:crypto';
+import { rsSuccess, schemaOf } from './types.js';
+import { rsFail, rsValidationError, rsConfirmationError } from '../errors.js';
+import { objIdOf, formIdOf, getFormLayout, getFormLayoutMeta, saveFormData, runEsb, getFormButtons, resolvePersonId, getDsOptions, cachedDsMap, findMenuNode, resolveCurrentUser, buildCardUrl, buildListLocateUrl, talentLinkExtra, pickSaveButtonActions, computeRequiredHint, randHex32, } from '../shared.js';
+// 面试计划表单字段 dataKey（缓存 fields 里取）。
+// 注意：digital_id 不放入此列表——它只在「面试方式含 AI」时才是必填，
+// 放进来会让未部署数字人的环境连非 AI 面试都建不了（单独按需校验）。
+const 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'];
+// 面试计划常用字段中文名（仅用于把联动必填结果说人话；字段 id 一律运行时解析）
+const FIELD_LABELS = {
+    subject: '面试主题', start_time: '开始时间', end_time: '结束时间', interview_type: '面试方式',
+    interview_session: '面试轮次', interviewer: '面试官', position_manage_id: '应聘职位',
+    talent_id: '人才', candidate_manage_id: '应聘管理', mobile: '手机', email: '邮箱',
+    digital_id: 'AI面试方案', interview_paper_id: '面试试卷', send_channel: '发送渠道',
+    notice_mould: '通知模板', affiliate_schedule: '关联日程', union_status: '状态',
+    interview_location: '面试地点',
+};
+const labelOf = (k) => (FIELD_LABELS[k] ? FIELD_LABELS[k] + '(' + k + ')' : k);
+const ASSIGNED_API_RE = /\/api\/recruit\/candidate\/assignedInterview/;
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+async function resolveCandidate(ctx, talentId) {
+    const { host, cache } = ctx;
+    const extra = { ebBusinessId: cache.lists?.talent?.listId || '' };
+    const hr = await host.request({ path: '/api/recruit/talent/hasRights?formDataId=' + talentId, method: 'POST', headers: extra });
+    if (!(hr?.data || []).includes('READ'))
+        throw rsFail('无 READ 权限');
+    const r1 = randHex32().slice(0, 6);
+    const pq = await host.request({ path: '/api/recruit/candidate/getCandidateCardPrepareQuery?talentId=' + talentId + '&randomkey_' + r1 + '=' + r1, method: 'GET', headers: extra });
+    const batchId = pq?.data?.batchId;
+    const v = randHex32().slice(0, 6);
+    // otherInfo 与 baseInfo 只依赖 batchId、互不引用 → 并行（省 1 RTT）。
+    // 两者都是只读 GET；失败时 Promise.all 抛第一个错，行为与串行等价（仅多一个无害请求）。
+    const [o, b2] = await Promise.all([
+        host.request({ path: '/api/recruit/candidate/getCandidateCardOtherInfo?talentId=' + talentId + '&batchId=' + batchId + '&v=' + v + '&randomkey_ab=ab', method: 'GET', headers: extra }),
+        host.request({ path: '/api/recruit/candidate/getCandidateCardBaseInfo?talentId=' + talentId + '&batchId=' + batchId + '&v=' + v + '&randomkey_cd=cd', method: 'GET', headers: extra }),
+    ]);
+    const b = o?.data?.currentCandidateBatch || {};
+    let name = b?.talent?.name;
+    // 手机号/邮箱必须显式取：页面是「按 talent_id 联动带出」，直接调 saveFormData 不会触发联动，
+    // 不写就会落空（AI面试要求邮箱必填）。取 BaseInfo 的 talent.telephone / talent.email。
+    let mobile = '';
+    let email = '';
+    const tb = b2?.data?.talent || {};
+    if (!name)
+        name = tb.hrm?.name || tb.name;
+    mobile = String(tb.telephone || tb.mobile || '').trim();
+    email = String(tb.email || '').trim();
+    return {
+        talentId,
+        name,
+        mobile,
+        email,
+        candidateManageId: b?.id || b?.candidateManageId || null,
+        positionId: b?.position?.id || null,
+        positionName: b?.position?.name,
+    };
+}
+// 候选人定位：mobile/name → talentId（人才库列表检索）。手机号优先且命中唯一即采用；
+// 姓名可能多条 → 返回 candidates 由用户选择（绝不自动挑一个）。
+async function locateTalent(ctx, opts) {
+    const { host, cache } = ctx;
+    const listId = cache.lists?.talent?.listId;
+    const objId = cache.forms?.talent_pool?.objId;
+    if (!listId || !objId)
+        throw rsFail('环境缓存缺少人才列表（lists.talent / forms.talent_pool）');
+    const fields = cache.fields[objId] || {};
+    const nameKey = fields.candidate_name || fields.name;
+    if (opts.mobile && !fields.telephone)
+        throw rsFail('环境缓存缺少人才手机字段（telephone）');
+    if (!opts.mobile && opts.name && !nameKey)
+        throw rsFail('环境缓存缺少人才姓名字段（candidate_name/name）');
+    const conds = {};
+    if (opts.mobile) {
+        const mf = 'field_' + fields.telephone;
+        conds[mf] = [{ [mf]: opts.mobile, [mf + '_condition_type']: 'like' }];
+    }
+    if (opts.name && !opts.mobile) {
+        const nf = 'field_' + nameKey;
+        conds[nf] = [{ [nf]: opts.name, [nf + '_condition_type']: 'like' }];
+    }
+    const body = {
+        current: 1, pageSize: 20, tableuid: randHex32(),
+        listId,
+        searchParamData: { searchType: '3', commonSearchFields: conds, type: 'and' },
+        terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1, recheckQuery: 1,
+        isFollow: 0, isShareToMe: 0, filterCondition: {},
+        cusMenuId: cache.lists.talent.cusMenuId, urlPageTitle: '人才库',
+        menuName: cache.lists.talent.menuName || '人才管理',
+    };
+    const r = await host.request({
+        path: '/api/ebuilder/form/list/getListDatas?passid=' + objId + '&cid=' + objId,
+        body, headers: { ebBusinessId: listId },
+    });
+    const disp = r?.data?.displayData;
+    const raw = r?.data?.data || [];
+    const rows = Array.isArray(disp) && disp.length ? disp : raw;
+    return rows.map((x) => ({
+        talentId: x.form_data_id || x.id || null,
+        name: x.candidate_name || x.name || null,
+        mobile: x.telephone || null,
+        position: x.position_manage_id || x.position || null,
+        recruitStatus: x.recruit_status || null,
+    }));
+}
+// ── AI 面试方案（面试数字人配置表）：objId 走 tag、listId 走菜单，全部运行时解析 ──
+const PLAN_NAME_KEYS = ['msfa_name', 'digital_name', 'plan_name', 'scheme_name'];
+function digitalMenuOf(cache) {
+    const hit = cache.digitalHumanMenu;
+    if (hit?.listId)
+        return hit;
+    const menus = cache.lists?.all_search || cache.menus || [];
+    return menus.find((m) => (m.menuName || '').includes('面试数字人'))
+        || menus.find((m) => (m.menuName || '').includes('数字人配置'))
+        || null;
+}
+async function digitalObjIdOf(ctx) {
+    const cached = ctx.cache.forms?.digital_human?.objId;
+    if (cached)
+        return String(cached);
+    const r = await ctx.host.request({ path: '/api/ebuilder/form/obj/getObjsByTag?appId=' + ctx.appId + '&tag=uf_rcrt_digital_human', method: 'GET' });
+    const d = r?.data;
+    return Array.isArray(d) && d.length ? String(d[0].id || '') : '';
+}
+// AI 面试方案候选：优先走「关联字段候选项」接口（不依赖菜单/列表，标准包未配菜单也可用），
+// 失败再回退「面试数字人配置」列表。两种都不写死任何 id。
+async function listDigitalPlans(opts) {
+    const { ctx, formId, layoutId, fieldId } = opts;
+    const { host, cache } = ctx;
+    // ① 关联字段候选（实测可用，返回 {id,name,ebObjId}）
+    try {
+        const body = {
+            browserMultiple: false,
+            newly: 1,
+            searchValue: '',
+            formParam: JSON.stringify({ formId, layoutId, fieldId, filterItems: [], module: 'ebuilderform', dataDetails: [] }),
+            openScroll: true,
+            controlId: fieldId,
+            businessId: formId,
+            variableMap: {},
+        };
+        const r = await host.request({ path: '/api/ebuilder/form/common/browser/complete/ebuilder', body });
+        if (r?.status !== false && r?.data) {
+            const list = r.data.data || [];
+            const items = list.filter((x) => x && x.id).map((x) => ({
+                id: String(x.id), name: String(x.name || '').trim(), position: '', desc: '',
+            }));
+            return { available: true, items, source: 'associate-complete' };
+        }
+    }
+    catch { /* 回退列表 */ }
+    // ② 列表兜底（需要菜单「面试数字人配置」）
+    const menu = digitalMenuOf(cache);
+    if (!menu?.listId) {
+        return { available: false, items: [], reason: '候选接口不可用，且当前环境未配置「面试数字人配置」列表菜单' };
+    }
+    let objId = '';
+    try {
+        const liBody = { cusMenuId: menu.cusMenuId, listId: menu.listId, urlPageTitle: menu.menuName };
+        liBody['appId_' + menu.listId] = ctx.appId;
+        const li = await host.request({ path: '/api/ebuilder/form/list/listInit', body: liBody });
+        objId = String(li?.data?.objid || '');
+    }
+    catch { /* 回退 tag 解析 */ }
+    if (!objId)
+        objId = await digitalObjIdOf(ctx).catch(() => '');
+    if (!objId) {
+        return { available: false, items: [], reason: '未能解析「面试数字人配置」对象 id（listInit / tag 均失败）' };
+    }
+    const rows = [];
+    let cur = 1;
+    const size = 100;
+    for (;;) {
+        const body = {
+            current: cur, pageSize: size, tableuid: randHex32(),
+            listId: menu.listId,
+            searchParamData: { searchType: '3', type: 'and' },
+            terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1,
+            recheckQuery: 1, isFollow: 0, isShareToMe: 0, filterCondition: {},
+            cusMenuId: menu.cusMenuId, urlPageTitle: menu.menuName, menuName: menu.menuName,
+        };
+        const r = await host.request({
+            path: `/api/ebuilder/form/list/getListDatas?passid=${objId}&cid=${objId}`,
+            body, headers: { ebBusinessId: menu.listId },
+        });
+        const page = r?.data?.data || [];
+        rows.push(...page);
+        if (page.length < size)
+            break;
+        cur++;
+        if (cur > 20)
+            break; // 防御：最多 2000 条
+    }
+    const items = rows.map((x) => {
+        const nk = PLAN_NAME_KEYS.find((k) => String(x[k] || '').trim());
+        return {
+            id: String(x.form_data_id || x.id || ''),
+            name: String(nk ? x[nk] : '').trim(),
+            position: String(x.zwmc || '').trim(),
+            desc: String(x.zwjs || '').trim(),
+        };
+    }).filter((x) => x.id);
+    return { available: true, items, listId: menu.listId, objId, menuName: menu.menuName, source: 'list' };
+}
+// 方案匹配：id 精确 → 名称全等 → 名称包含；多条命中视为歧义，绝不自动取第一条
+function pickDigitalPlan(items, key) {
+    const k = String(key || '').trim();
+    if (!k)
+        return { plan: null, ambiguous: [] };
+    const byId = items.filter((x) => x.id === k);
+    if (byId.length === 1)
+        return { plan: byId[0], ambiguous: [] };
+    const byExact = items.filter((x) => x.name === k);
+    if (byExact.length === 1)
+        return { plan: byExact[0], ambiguous: [] };
+    const byLike = items.filter((x) => x.name.includes(k));
+    if (byLike.length === 1)
+        return { plan: byLike[0], ambiguous: [] };
+    return { plan: null, ambiguous: byLike };
+}
+function planBrief(items) {
+    return (items || []).map((x) => x.name + (x.position ? '（岗位：' + x.position + '）' : '') + ' [id=' + x.id + ']').join('；');
+}
+async function buildPlan(opts) {
+    const { ctx, talentId, positionId, interviewer, type, session, start, end, email, mobile, aiPlan } = opts;
+    const { host, appId, cache } = ctx;
+    const objId = objIdOf(cache, 'interview_plan');
+    const formId = formIdOf(cache, 'interview_plan');
+    const fields = cache.fields[objId] || {};
+    const fid = (k) => fields[k];
+    for (const k of DATAKEYS)
+        if (!fid(k))
+            throw rsFail('面试计划缺少字段 ' + k + '（ds/fields 解析不到）');
+    const cand = await resolveCandidate(ctx, talentId);
+    const positionIdFinal = positionId || (cand.positionId ? String(cand.positionId) : '');
+    if (!positionIdFinal) {
+        throw rsFail('该人才尚未关联职位（简历池人才）：安排面试必须先选定一个职位。'
+            + '请从在招职位中推荐并由用户选定后，带 positionId 重试（prepare 可先出确认摘要）。');
+    }
+    const candManageId = cand.candidateManageId ? String(cand.candidateManageId) : '';
+    if (!candManageId)
+        throw rsFail('未定位到应聘管理记录（candidateManageId），请确认候选人已有应聘批次');
+    // 面试方式/轮次枚举：环境缓存 field_options 已有同名映射时直接反转使用（省 2 请求），未覆盖才回源
+    const typeMap = cachedDsMap(cache, objId, 'interview_type') || await getDsOptions(host, objId, fid('interview_type'), appId);
+    const sessionMap = cachedDsMap(cache, objId, 'interview_session') || await getDsOptions(host, objId, fid('interview_session'), appId);
+    const typeId = typeMap[type];
+    if (!typeId)
+        throw rsFail('面试方式「' + type + '」不在枚举中（' + Object.keys(typeMap).join('/') + '）');
+    const sessionId = sessionMap[session];
+    if (!sessionId)
+        throw rsFail('面试轮次「' + session + '」不在枚举中（' + Object.keys(sessionMap).join('/') + '）');
+    // 手机号/邮箱：页面按 talent_id 联动带出；直接落库必须显式写。用户显式输入优先于人才资料。
+    const emailFromTalent = String(cand.email || '').trim();
+    const mobileFromTalent = String(cand.mobile || '').trim();
+    const emailInput = String(email || '').trim();
+    const mobileInput = String(mobile || '').trim();
+    if (emailInput)
+        cand.email = emailInput;
+    if (mobileInput)
+        cand.mobile = mobileInput;
+    const emailSource = emailInput ? 'user' : (emailFromTalent ? 'talent' : 'none');
+    const mobileSource = mobileInput ? 'user' : (mobileFromTalent ? 'talent' : 'none');
+    // AI 面试：邮箱必填（服务端按邮箱发面试通知/录屏链接）。缺失时阻断创建，不静默写空、不降级。
+    const isAI = /AI|人工智能/i.test(String(type));
+    if (isAI && !cand.email) {
+        throw rsFail('AI面试必须填写候选人邮箱（必填）：该人才资料未维护邮箱（talentId=' + talentId + '）。'
+            + '请用户提供邮箱后重试（email 参数）；或先到人才资料补全邮箱再安排。');
+    }
+    if (cand.email && !EMAIL_RE.test(cand.email)) {
+        throw rsFail('候选人邮箱格式不正确：' + cand.email + '。请提供有效邮箱后重试。');
+    }
+    if (!cand.mobile) {
+        throw rsFail('未取到候选人手机号（talentId=' + talentId + '），请先在人才资料补全手机号，或用 mobile 参数指定');
+    }
+    // 面试官解析与 AI 方案解析互不依赖 → 提前启动、并行等待（省 1 RTT）。
+    // 包装成永不 reject 的 promise：即便 AI 方案校验先抛错提前退出，也不会产生 unhandledRejection；
+    // 真正 await 时若失败再抛原错，保持与串行完全一致的错误语义。
+    const interviewerTask = (async () => {
+        if (interviewer) {
+            return { id: await resolvePersonId(host, fid('interviewer'), interviewer), name: interviewer };
+        }
+        const cu = await resolveCurrentUser(host);
+        return cu ? { id: cu.id, name: cu.name } : { id: null, name: interviewer };
+    })().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+    // AI 面试方案（digital_id）——与邮箱同为 AI 面试必填。未指定时不自动取第一条。
+    let aiPlanPicked = null;
+    let aiPlanOptions = { available: false, items: [] };
+    let layoutId = '';
+    const digitalFid = fid('digital_id');
+    let interviewerId = null;
+    let interviewerName = interviewer;
+    if (isAI) {
+        if (!digitalFid)
+            throw rsFail('面试计划表单缺少「AI面试方案」字段（dataKey=digital_id），无法安排 AI 面试');
+        layoutId = await getFormLayout(host, formId);
+        // 方案候选与面试官并行（方案依赖 layoutId，故在其后）
+        const [plans, ivr] = await Promise.all([listDigitalPlans({ ctx, formId, layoutId, fieldId: digitalFid }), interviewerTask]);
+        if (!ivr.ok)
+            throw ivr.error;
+        interviewerId = ivr.value.id;
+        interviewerName = ivr.value.name;
+        aiPlanOptions = plans;
+        if (!aiPlanOptions.available) {
+            throw rsFail('AI面试必须选择「AI面试方案」，但' + aiPlanOptions.reason + '；请先在该环境维护面试数字人配置');
+        }
+        if (!aiPlanOptions.items.length) {
+            throw rsFail('「面试数字人配置」暂无可选方案，请先在「面试数字人配置」中新增方案后再安排 AI 面试');
+        }
+        if (aiPlan) {
+            const { plan, ambiguous } = pickDigitalPlan(aiPlanOptions.items, aiPlan);
+            if (plan)
+                aiPlanPicked = plan;
+            else if (ambiguous.length > 1)
+                throw rsFail('AI面试方案「' + aiPlan + '」命中多个：' + planBrief(ambiguous) + '，请指明具体方案');
+            else
+                throw rsFail('未找到 AI面试方案「' + aiPlan + '」。可选：' + planBrief(aiPlanOptions.items));
+        }
+    }
+    else {
+        const ivr = await interviewerTask;
+        if (!ivr.ok)
+            throw ivr.error;
+        interviewerId = ivr.value.id;
+        interviewerName = ivr.value.name;
+    }
+    if (!interviewerId)
+        throw rsFail('面试官未指定且无法解析当前登录用户，请用 interviewer 参数指定');
+    const dataDetails = [
+        { formField: { id: fid('subject') }, content: (cand.positionName ? cand.positionName + '-' : '') + cand.name + '的面试' },
+        { formField: { id: fid('start_time') }, content: start },
+        { formField: { id: fid('end_time') }, content: end },
+        { formField: { id: fid('interview_type') }, dataOptions: [{ optionId: typeId, content: type }] },
+        { formField: { id: fid('interview_session') }, dataOptions: [{ optionId: sessionId, content: session }] },
+        { formField: { id: fid('interviewer') }, dataOptions: [{ optionId: interviewerId, content: interviewerName }] },
+        { formField: { id: fid('mobile') }, content: cand.mobile },
+        ...(cand.email ? [{ formField: { id: fid('email') }, content: cand.email }] : []),
+        { formField: { id: fid('position_manage_id') }, dataOptions: [{ optionId: positionIdFinal, content: cand.positionName }] },
+        { formField: { id: fid('talent_id') }, dataOptions: [{ optionId: talentId, content: cand.name }] },
+        { formField: { id: fid('candidate_manage_id') }, dataOptions: [{ optionId: candManageId, content: candManageId }] },
+    ];
+    if (aiPlanPicked) {
+        dataDetails.push({ formField: { id: digitalFid }, dataOptions: [{ optionId: aiPlanPicked.id, content: aiPlanPicked.name }] });
+    }
+    return {
+        host: ctx.host,
+        objId, formId, appId, dataDetails, cand, typeId, sessionId, interviewerId, isAI, layoutId,
+        typeOptions: Object.fromEntries(Object.entries(typeMap).map(([n, id]) => [String(id), n])),
+        aiPlanPicked, aiPlanOptions,
+        summary: {
+            action: '安排面试',
+            talent: cand.name + '（talentId=' + talentId + '）',
+            position: cand.positionName, type, session,
+            time: start + ' ~ ' + end, interviewer: interviewerName,
+            mobile: cand.mobile + '（来源：' + (mobileSource === 'user' ? '本次指定' : '人才资料') + '）',
+            email: (cand.email || '（未提供）') + '（来源：' + (emailSource === 'user' ? '本次指定' : emailSource === 'talent' ? '人才资料' : '缺失') + '）',
+            aiPlan: isAI
+                ? (aiPlanPicked ? aiPlanPicked.name + '（id=' + aiPlanPicked.id + '）' : '未选择（AI面试必填，需用户指定）')
+                : '（非 AI 面试，不适用）',
+            isAIInterview: isAI,
+        },
+    };
+}
+// 保存按钮动作链：system 由 saveFormData 完成，其余按 showOrder 顺序逐条执行
+async function resolveSaveActions(plan) {
+    const layoutId = plan.layoutId || await getFormLayout(plan.host, plan.formId);
+    const acts = pickSaveButtonActions(await getFormButtons(plan.host, plan.objId, layoutId));
+    return acts.filter((a) => a.actionType !== 'system');
+}
+async function callAssignedInterview(host, formDataId) {
+    const r = await host.request({ path: '/api/recruit/candidate/assignedInterview?formDataId=' + formDataId, method: 'POST' });
+    // 页面判断用松散比较 res.code == '200'，保持一致（code 可能是数字或字符串）
+    const ok = String(r?.code) === '200' || r?.status === true || r?.success === true;
+    if (!ok)
+        throw rsFail('分配面试（assignedInterview）失败：' + (r?.msg || JSON.stringify(r).slice(0, 200)));
+    return r?.data || {};
+}
+async function execSaveActions(plan, formDataId) {
+    const host = plan.host;
+    const executed = [];
+    const warnings = [];
+    let assigned = null;
+    let actions = [];
+    try {
+        actions = await resolveSaveActions(plan);
+    }
+    catch (e) {
+        warnings.push('读取「保存」按钮动作链失败：' + e.message + '；已按「保存 + 分配面试」兜底执行');
+    }
+    const hasAssigned = actions.some((a) => ASSIGNED_API_RE.test(a.ecode || ''));
+    if (!actions.length)
+        warnings.push('未解析到「保存」按钮的后续动作（该环境可能未配置，或按钮配置接口不可用）；已按「保存 + 分配面试」兜底');
+    for (const a of actions) {
+        const base = { order: a.showOrder, name: a.name, type: a.actionType };
+        if (a.actionType === 'esb') {
+            const r = await runEsb(host, { objId: plan.objId, dataIds: formDataId, esbActionIds: a.id });
+            const ok = r?.status !== false;
+            executed.push({ ...base, ok, msg: r?.successMsg || r?.failMsg || '' });
+            if (!ok)
+                throw rsFail('「保存」后续动作「' + (a.name || a.id) + '」执行失败：' + (r?.failMsg || '未知原因'));
+        }
+        else if (a.actionType === 'jsCode') {
+            if (ASSIGNED_API_RE.test(a.ecode || '')) {
+                assigned = await callAssignedInterview(host, formDataId);
+                executed.push({ ...base, ok: true, msg: '等价调用 assignedInterview（分配面试）' });
+            }
+            else {
+                executed.push({ ...base, ok: null, msg: '自定义脚本动作，服务端无法等价执行，已跳过' });
+                warnings.push('动作「' + (a.name || a.id) + '」为自定义 jsCode，未执行；如需该效果请在页面点保存');
+            }
+        }
+        else {
+            executed.push({ ...base, ok: null, msg: '非服务端动作（' + a.actionType + '），已跳过' });
+        }
+    }
+    if (!hasAssigned) {
+        assigned = await callAssignedInterview(host, formDataId);
+        executed.push({ order: 999, name: '分配面试（兜底）', type: 'api', ok: true, msg: '该环境未把分配面试配置为保存动作' });
+        warnings.push('该环境「保存」动作链未解析到 assignedInterview，已按招聘业务契约兜底调用');
+    }
+    return { executed, warnings, assigned };
+}
+// 读取表单联动声明，算出「当前面试方式下必填、但本次未提供且无默认值」的字段（只读提示，不阻断）
+async function resolveRequiredHint(plan, ctx) {
+    const fields = ctx.cache.fields[plan.objId] || {};
+    const meta = await getFormLayoutMeta(ctx.host, plan.formId);
+    if (!meta)
+        return { available: false, required: [], missing: [] };
+    return computeRequiredHint({
+        meta, fields,
+        typeName: plan.summary.type,
+        typeOptionId: plan.typeId,
+        typeOptions: plan.typeOptions || {},
+        dataDetails: plan.dataDetails,
+    });
+}
+// 人才卡片详情 URL（EB 详情页）：{baseUrl}/sp/ebdpage/view/{ebdDetailPageId}?talentId={id}
+function resolveTalentCardUrl(ctx, talentId) {
+    const pid = ctx.cache.ebdDetailPageId;
+    if (!pid)
+        return null;
+    return `${ctx.baseUrl}/sp/ebdpage/view/${pid}?talentId=${talentId}${talentLinkExtra(ctx.cache)}`;
+}
+// 面试管理列表 URL：优先环境缓存菜单，回退 allMenus 解析（别名匹配，跨环境不写死）
+async function resolveInterviewListUrl(ctx) {
+    const { host, appId, baseUrl, cache } = ctx;
+    const cachedMenu = cache.lists?.interview;
+    if (cachedMenu?.listId && cachedMenu.combinationId) {
+        return `${baseUrl}/ebdapp/view/${appId}/combination/${cachedMenu.combinationId}-${cachedMenu.listId || cachedMenu.cusMenuId}/search/${cachedMenu.pageId || cachedMenu.cusMenuId}?terminal=PC&cusMenuId=${cachedMenu.cusMenuId}`;
+    }
+    const r = await host.request({ path: `/api/cusapp/app/allMenus?isFront=1&appId=${appId}&terminalType=PC`, method: 'GET' });
+    const flat = [];
+    (function walk(ns) { for (const n of (ns || []))
+        if (n && typeof n === 'object') {
+            flat.push(n);
+            walk(n.children || n.childs);
+        } })(r?.data?.cusAppMenus || r?.data);
+    const node = findMenuNode(flat, ['面试管理', '面试安排列表', '面试安排'], (n) => n.combinationId && n.id && n.pageId);
+    if (!node)
+        return null;
+    return `${baseUrl}/ebdapp/view/${appId}/combination/${node.combinationId}-${node.id}/search/${node.pageId}?terminal=PC&cusMenuId=${node.id}`;
+}
+// 默认时间：与页面「选 AI面试」联动一致 —— AI=当前时间~+7天，其它=1小时。分钟精度。
+function nowAndEnd(type) {
+    const isAI = /AI|人工智能/i.test(String(type || ''));
+    const d = new Date();
+    const f = (x) => String(x).padStart(2, '0');
+    const fmt = (x) => x.getFullYear() + '-' + f(x.getMonth() + 1) + '-' + f(x.getDate()) + ' ' + f(x.getHours()) + ':' + f(x.getMinutes());
+    const s = fmt(d);
+    const e = fmt(new Date(d.getTime() + (isAI ? 7 * 24 * 3600 * 1000 : 3600 * 1000)));
+    return { s, e, isAI };
+}
+function shiftTime(str, addMs) {
+    const m = /^(\d{4})-(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{2})$/.exec(String(str || '').trim());
+    if (!m)
+        return null;
+    const d = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]));
+    if (Number.isNaN(d.getTime()))
+        return null;
+    const t = new Date(d.getTime() + addMs);
+    const f = (x) => String(x).padStart(2, '0');
+    return t.getFullYear() + '-' + f(t.getMonth() + 1) + '-' + f(t.getDate()) + ' ' + f(t.getHours()) + ':' + f(t.getMinutes());
+}
+function makeCtx(env) {
+    return (async () => {
+        const host = env.host;
+        const session = await host.getSession();
+        const cache = await env.recruitContext();
+        return { host, baseUrl: session.baseUrl.replace(/\/+$/, ''), appId: cache.appId, cache };
+    })();
+}
+async function locateTalentId(ctx, args) {
+    if (args.talentId)
+        return String(args.talentId);
+    if (!args.mobile && !args.name) {
+        throw rsValidationError('talent_required', '请提供 talentId，或 mobile/name 之一用于定位候选人');
+    }
+    const cands = await locateTalent(ctx, { mobile: args.mobile, name: args.name });
+    if (!cands.length) {
+        throw rsFail('人才库未找到' + (args.mobile ? '手机号为 ' + args.mobile : '姓名为 ' + args.name) + '的候选人（检索条件：人才库列表，关键词 like）', { located: false, candidates: [] });
+    }
+    if (cands.length > 1) {
+        throw rsFail('匹配到多条同' + (args.mobile ? '手机号' : '姓名') + '候选人，请用户选择后再安排面试（绝不自动挑一个）', { located: false, needChoice: true, candidates: cands });
+    }
+    return String(cands[0].talentId);
+}
+const baseInput = {
+    talentId: { type: 'string', description: '人才 id（与 mobile/name 三选一）' },
+    mobile: { type: 'string', pattern: '^\\d{6,20}$', description: '手机号定位（唯一命中自动采用）' },
+    name: { type: 'string', description: '姓名定位（多条会要求用户选择）' },
+    positionId: { type: 'string', description: '应聘职位 id（简历池人才必填）' },
+    interviewer: { type: 'string', description: '面试官姓名（缺省=当前登录用户）' },
+    type: { type: 'string', description: '面试方式（现场面试/视频面试/电话面试/AI面试；含 AI 时邮箱与方案必填）' },
+    session: { type: 'string', description: '面试轮次（初试/复试/…）' },
+    start: { type: 'string', pattern: '^\\d{4}-\\d{1,2}-\\d{1,2}[ T]\\d{1,2}:\\d{2}$', description: '开始时间 YYYY-MM-DD HH:mm（缺省=当前时间）' },
+    end: { type: 'string', pattern: '^\\d{4}-\\d{1,2}-\\d{1,2}[ T]\\d{1,2}:\\d{2}$', description: '结束时间（缺省=AI +7天 / 其它 +1小时）' },
+    email: { type: 'string', description: '候选人邮箱（AI 面试必填；补录值优先于人才资料）' },
+    aiPlan: { type: 'string', description: 'AI 面试方案名或 id（AI 面试必填；不传则 prepare 列出候选）' },
+};
+async function prepare(args, env) {
+    const ctx = await makeCtx(env);
+    const talentId = await locateTalentId(ctx, args);
+    const auto = nowAndEnd(args.type || '现场面试');
+    const startTime = args.start || auto.s;
+    const endTime = args.end || (args.start ? (shiftTime(String(args.start), auto.isAI ? 7 * 24 * 3600 * 1000 : 3600 * 1000) || auto.e) : auto.e);
+    const plan = await buildPlan({
+        ctx, talentId,
+        positionId: args.positionId ? String(args.positionId) : undefined,
+        interviewer: args.interviewer ? String(args.interviewer) : undefined,
+        type: String(args.type || '现场面试'), session: String(args.session || '初试'),
+        start: String(startTime), end: String(endTime),
+        email: args.email ? String(args.email) : undefined,
+        mobile: args.mobile ? String(args.mobile) : undefined,
+        aiPlan: args.aiPlan ? String(args.aiPlan) : undefined,
+    });
+    plan.host = ctx.host;
+    const aiPlanCandidates = plan.isAI
+        ? (plan.aiPlanOptions.items || []).map((x) => ({ id: x.id, name: x.name, position: x.position }))
+        : [];
+    // 注：不再在 prepare 阶段解析「保存」按钮动作链——该信息属内部执行明细，
+    // 输出纪律明确禁止展示（openai.yaml：不展示 saveActions 等）；apply 时由 execSaveActions 自解析。
+    // 省 1 个 RTT（getFormButtons）。
+    const requiredHint = await resolveRequiredHint(plan, ctx).catch(() => null);
+    if (requiredHint?.missing?.length)
+        requiredHint.missingLabels = requiredHint.missing.map(labelOf);
+    // 页面默认方案（defaultDetails 里 digital_id 的值）——标到候选上，方便用户直接说"用默认"
+    const defPlan = plan.isAI ? requiredHint?.defaultValues?.digital_id : null;
+    if (defPlan?.optionId) {
+        for (const x of aiPlanCandidates)
+            if (String(x.id) === String(defPlan.optionId))
+                x.isDefault = true;
+    }
+    const defaultAiPlan = defPlan?.optionId ? { id: defPlan.optionId, name: defPlan.content } : undefined;
+    const willSubmit = { formId: plan.formId, objId: plan.objId, dataDetails: plan.dataDetails };
+    const { createHash } = await import('node:crypto');
+    const fp = createHash('sha256').update(JSON.stringify(willSubmit)).digest('hex');
+    const continuation = await env.continuation.issue({ operation: 'recruit-stage.interview.arrange.apply', fingerprint: fp });
+    return rsSuccess('recruit-stage.interview.arrange.prepare', {
+        mode: 'prepare', ...plan.summary,
+        needAiPlan: plan.isAI && !plan.aiPlanPicked,
+        aiPlans: plan.isAI ? aiPlanCandidates : undefined,
+        defaultAiPlan,
+        aiPlanHint: plan.isAI && !plan.aiPlanPicked
+            ? 'AI面试方案为必填：请把 aiPlans 列给用户选择（isDefault=true 为页面默认方案），确认后带 aiPlan 重跑 apply'
+            : undefined,
+        requiredHint,
+        willSubmit,
+    }, {
+        continuation,
+        fingerprint: fp,
+        confirmHint: '用户明确确认后，携带 confirm:true 与本 continuation 调用 recruit-stage.interview.arrange.apply（AI 面试需先选定 aiPlan）',
+    });
+}
+async function apply(args, env) {
+    if (args.confirm !== true)
+        throw rsConfirmationError('recruit-stage.interview.arrange.apply', { hint: '写操作必须显式 confirm:true' });
+    if (!args.continuation)
+        throw rsValidationError('continuation_required', '缺少 continuation（来自 prepare 的 meta）');
+    const payload = await env.continuation.verify(String(args.continuation), 'recruit-stage.interview.arrange.apply');
+    const ctx = await makeCtx(env);
+    const talentId = await locateTalentId(ctx, args);
+    const auto = nowAndEnd(args.type || '现场面试');
+    const startTime = args.start || auto.s;
+    const endTime = args.end || (args.start ? (shiftTime(String(args.start), auto.isAI ? 7 * 24 * 3600 * 1000 : 3600 * 1000) || auto.e) : auto.e);
+    const plan = await buildPlan({
+        ctx, talentId,
+        positionId: args.positionId ? String(args.positionId) : undefined,
+        interviewer: args.interviewer ? String(args.interviewer) : undefined,
+        type: String(args.type || '现场面试'), session: String(args.session || '初试'),
+        start: String(startTime), end: String(endTime),
+        email: args.email ? String(args.email) : undefined,
+        mobile: args.mobile ? String(args.mobile) : undefined,
+        aiPlan: args.aiPlan ? String(args.aiPlan) : undefined,
+    });
+    plan.host = ctx.host;
+    // AI 面试方案必填：未选定直接阻断，不落库、不执行动作链
+    if (plan.isAI && !plan.aiPlanPicked) {
+        throw rsFail('AI面试必须选择「AI面试方案」（必填），当前未指定。可选方案：'
+            + (plan.aiPlanOptions.items?.length ? planBrief(plan.aiPlanOptions.items) : '（无）')
+            + '。请让用户选择后带 aiPlan 重试。');
+    }
+    const willSubmit = { formId: plan.formId, objId: plan.objId, dataDetails: plan.dataDetails };
+    const { createHash } = await import('node:crypto');
+    if (payload.fingerprint !== createHash('sha256').update(JSON.stringify(willSubmit)).digest('hex')) {
+        throw rsValidationError('fingerprint_mismatch', '待提交内容与 prepare 确认摘要不一致，请重新 prepare 确认后再 apply');
+    }
+    const formDataId = await saveFormData(ctx.host, {
+        appId: plan.appId, formId: plan.formId, objId: plan.objId,
+        name: '面试管理-' + plan.cand.name + ' ' + plan.summary.time, dataDetails: plan.dataDetails,
+    });
+    const actionsRun = await execSaveActions(plan, formDataId);
+    const detailUrl = buildCardUrl(ctx.baseUrl, plan.objId, formDataId);
+    const listLocateUrl = buildListLocateUrl(ctx.baseUrl, ctx.appId, (ctx.cache.lists?.interview?.listId) || '', plan.objId, formDataId);
+    return rsSuccess('recruit-stage.interview.arrange.apply', {
+        mode: 'apply', result: 'success', interviewFormId: formDataId,
+        interviewCardUrl: detailUrl,
+        viewLink: detailUrl ? `[查看 ${plan.cand.name || ''} 的面试安排详情](${detailUrl})` : null,
+        listLocateLink: listLocateUrl ? `[打开面试管理列表（已定位本次面试安排）](${listLocateUrl})` : null,
+        agentNote: '产物 = 两个 Markdown 链接（平台实证可点击）：① viewLink 面试安排详情页 ② listLocateLink 面试管理列表并右侧滑出本次面试安排；按顺序原样放回答正文，缺哪个只给另一个、不输出半截。不要包 browsertool / <artifact> 标签。',
+        aiPlan: plan.isAI && plan.aiPlanPicked ? { id: plan.aiPlanPicked.id, name: plan.aiPlanPicked.name } : undefined,
+        saveActions: actionsRun.executed,
+        warnings: actionsRun.warnings,
+        assigned: actionsRun.assigned || {},
+    });
+}
+async function prefill(args, env) {
+    const ctx = await makeCtx(env);
+    const talentId = await locateTalentId(ctx, args);
+    const objId = objIdOf(ctx.cache, 'interview_plan');
+    const formId = formIdOf(ctx.cache, 'interview_plan');
+    const fields = ctx.cache.fields[objId] || {};
+    const typeKey = String(args.type || 'AI面试');
+    const typeFid = fields.interview_type;
+    if (!typeFid)
+        throw rsFail('面试计划缺少字段 interview_type（ds/fields 解析不到）');
+    const typeMap = cachedDsMap(ctx.cache, objId, 'interview_type') || await getDsOptions(ctx.host, objId, typeFid, ctx.appId);
+    const typeId = typeMap[typeKey];
+    if (!typeId)
+        throw rsFail('面试方式「' + typeKey + '」不在枚举中（' + Object.keys(typeMap).join('/') + '）');
+    const cardUrl = resolveTalentCardUrl(ctx, talentId);
+    const listUrl = await resolveInterviewListUrl(ctx).catch(() => null);
+    const jsExpr = `(() => { const W = window.WeFormSDK; const i = W && W.getWeFormInstance('ebuilderform', '${formId}');`
+        + ` if (!i) return 'no-form-instance(请先在人才卡片点「安排面试」打开面试安排表单)';`
+        + ` try { i.changeFieldValue('field${typeFid}', { value: '${typeId}' }); return 'ok 面试方式=${typeKey}'; }`
+        + ` catch (e) { return 'err:' + e.message; } })()`;
+    return rsSuccess('recruit-stage.interview.arrange.prefill', {
+        mode: 'prefill',
+        action: '安排面试（打开表单 + 选面试方式，人工核对保存；不落库）',
+        talentId,
+        interviewFormId: formId,
+        interviewType: typeKey,
+        interviewTypeOptionId: typeId,
+        talentCardUrl: cardUrl,
+        interviewListUrl: listUrl,
+        jsExpr,
+        steps: [
+            '1) 浏览器打开 talentCardUrl（需已登录该环境）→ 进入该候选人卡片',
+            '2) 点卡片上的「安排面试」→ 打开面试安排表单（主题/候选人/职位由表单默认值自动带入）',
+            '3) 在页面上下文执行 jsExpr → 选中「面试方式=' + typeKey + '」并触发联动（AI面试方案/面试官/开始结束时间自动带入）',
+            '4) 由 HR 核对（可按需调整）后点「保存」完成面试安排；本模式不写任何数据',
+            '5)（可选）打开 interviewListUrl 查看面试管理列表',
+        ],
+    });
+}
+export const interviewArrangeOperations = [
+    {
+        name: 'recruit-stage.interview.arrange.prepare',
+        resource: 'recruit.interview',
+        method: 'prepare',
+        action: 'interview.arrange.prepare',
+        summary: '安排面试确认摘要：定位候选人（talentId/手机号/姓名三选一）、解析面试方式/轮次枚举、AI 面试时列候选方案（绝不自动取第一条）与联动必填核对，不写入',
+        capability: 'recruit.interview.arrange',
+        risk: 'write',
+        requiresConfirmation: true,
+        inputSchema: schemaOf(baseInput, {}),
+        handler: prepare,
+    },
+    {
+        name: 'recruit-stage.interview.arrange.apply',
+        resource: 'recruit.interview',
+        method: 'apply',
+        action: 'interview.arrange.apply',
+        summary: '用户确认后安排面试：saveFormData → 按「保存」按钮动作链执行（ESB 日程/分配面试/AI 面试提醒），与页面点保存等价；返回双链接',
+        capability: 'recruit.interview.arrange',
+        risk: 'write',
+        requiresConfirmation: true,
+        inputSchema: schemaOf({ ...baseInput, confirm: { type: 'boolean' }, continuation: { type: 'string' } }, {}),
+        handler: apply,
+    },
+    {
+        name: 'recruit-stage.interview.arrange.prefill',
+        resource: 'recruit.interview',
+        method: 'prefill',
+        action: 'interview.arrange.prefill',
+        summary: '预填模式（人工保存）：输出人才卡片 URL + 面试管理列表 URL + 选面试方式的 jsExpr，触发表单联动后由 HR 核对保存，不落库',
+        capability: 'recruit.interview.arrange',
+        risk: 'read',
+        inputSchema: schemaOf(baseInput, {}),
+        handler: prefill,
+    },
+];
+void randomUUID;