weaver-work-cli 0.1.40 → 0.1.42

package/dist/shortcuts/ehr/operations/recruit-candidate-import.js

@@ -335,45 +335,122 @@ async function uploadResumeFile(env, filePath, fieldId, formId) {
     }
     return { fileid: String(fileid), name, size };
 }
-/** 平台标签：按名称在本环境标签清单里解析 id（同名优先公共），不自动创建。 */
-async function applyPlatformTags(env, talentId, tagNames) {
-    if (!tagNames.length)
-        return { applied: [], skipped: [] };
-    const list = (await env.host.request({
+/** 按名查标签（并行 type=0 公共 / type=1 个人）。服务端若忽略 name 会返回满页 → filtered=false，由调用方回退全量。
+ *  🔴 2026-11-04 修：原实现只取第 1 页 500 条，环境标签超 500 时后续标签永远匹配不到（静默跳过）。 */
+async function queryTagByName(env, name) {
+    const pageSize = 100;
+    const bodyOf = (type) => ({ type, name, order: 8, pageSize, pageNo: 1, search: 1, tagGroup: 0, tagModules: ['ebuilderform'] });
+    const rs = await Promise.all([0, 1].map((type) => env.host
+        .request({
         path: '/api/my/tag/query',
         method: 'POST',
-        body: { tagModules: ['ebuilderform'], current: 1, pageSize: 500 },
+        body: bodyOf(type),
         operation: 'ehr.recruit.candidate.import.apply',
-    }));
-    const rows = list?.data?.data || list?.data?.list || [];
+    })
+        .catch(() => null)));
+    const items = [];
+    let filtered = true;
+    for (const r of rs) {
+        const d = r?.data || {};
+        const list = Array.isArray(d.data) ? d.data : [];
+        const total = Number(d.total || 0);
+        if (list.length >= pageSize && total >= pageSize)
+            filtered = false;
+        items.push(...list);
+    }
+    return { items, filtered };
+}
+/** 单类型的全量标签（首轮取 total 后并发翻页，限并发 5、上限 40 页）——仅在按名查询不可用时回退 */
+async function fetchTagsOfType(env, type) {
+    const pageSize = 100;
+    const bodyOf = (pageNo) => ({ type, name: '', order: 8, pageSize, pageNo, search: 1, tagGroup: 0, tagModules: ['ebuilderform'] });
+    const requestPage = (pageNo) => env.host
+        .request({
+        path: '/api/my/tag/query',
+        method: 'POST',
+        body: bodyOf(pageNo),
+        operation: 'ehr.recruit.candidate.import.apply',
+    })
+        .catch(() => null);
+    const first = (await requestPage(1));
+    const d = first?.data || {};
+    const rows = Array.isArray(d.data) ? [...d.data] : [];
+    const total = Number(d.total || 0);
+    const pages = Math.min(40, Math.max(1, Math.ceil(total / pageSize)));
+    if (pages > 1 && rows.length) {
+        const rest = Array.from({ length: pages - 1 }, (_, i) => i + 2);
+        for (let i = 0; i < rest.length; i += 5) {
+            const batch = rest.slice(i, i + 5);
+            const rs = await Promise.all(batch.map((p) => requestPage(p)));
+            for (const r of rs) {
+                const list = r?.data?.data;
+                if (Array.isArray(list))
+                    rows.push(...list);
+            }
+        }
+    }
+    return rows;
+}
+/** 解析标签名 → id（同名优先公共），不创建标签。
+ *  ① 按名精确查询（N 个名字 → 1 轮请求）；② 服务端未按名过滤时才回退全量（不落盘、不缓存）。 */
+async function resolveTagIds(env, tagNames) {
+    const norm = (s) => String(s == null ? '' : s).trim().toLowerCase();
+    const uniqNames = [...new Set(tagNames.map((n) => String(n)).filter(Boolean))];
     const byName = new Map();
-    for (const row of rows) {
-        const name = String(row.name ?? row.tagName ?? '').trim();
-        const id = row.tagId ?? row.id;
-        if (name && id !== undefined && !byName.has(name))
-            byName.set(name, { id: String(id), name });
+    const absorb = (row) => {
+        const name = String(row?.name ?? row?.tagName ?? '').trim();
+        const id = row?.tagId ?? row?.id;
+        if (!name || id === undefined)
+            return;
+        const key = norm(name);
+        const prev = byName.get(key);
+        if (!prev)
+            byName.set(key, { id: String(id), name });
+        else if ((row?.type ?? 0) === 0)
+            byName.set(key, { id: String(id), name });
+    };
+    const probes = await Promise.all(uniqNames.map((n) => queryTagByName(env, n)));
+    const nameQueryUsable = probes.every((p) => p.filtered);
+    if (nameQueryUsable) {
+        for (const p of probes)
+            for (const item of p.items)
+                absorb(item);
     }
-    const tags = [];
-    const applied = [];
+    else {
+        for (const type of [0, 1]) {
+            const rows = await fetchTagsOfType(env, type).catch(() => []);
+            for (const item of rows)
+                absorb(item);
+        }
+    }
+    const resolved = [];
+    const found = [];
     const skipped = [];
     for (const name of tagNames) {
-        const hit = byName.get(name);
+        const hit = byName.get(norm(name));
         if (!hit) {
             skipped.push(name);
             continue;
         }
-        tags.push({ id: hit.id, name: hit.name, type: 0 });
-        applied.push(name);
+        resolved.push({ id: hit.id, name: hit.name, type: 0 });
+        found.push(name);
     }
-    if (tags.length) {
+    return { resolved, found, skipped };
+}
+/** 写入平台标签（解析 + batchAddEntityTag）。解析结果不存在时静默跳过，不自动创建标签。 */
+async function applyPlatformTags(env, talentId, tagNames) {
+    if (!tagNames.length)
+        return { applied: [], skipped: [] };
+    const r = await resolveTagIds(env, tagNames);
+    if (r.resolved.length) {
         await env.host.request({
             path: '/api/my/tag/common/batchAddEntityTag',
             method: 'POST',
-            body: { tags, batchDatas: [{ entityId: talentId, module: 'ebuilderform' }] },
+            body: { tags: r.resolved, batchDatas: [{ entityId: talentId, module: 'ebuilderform' }] },
             operation: 'ehr.recruit.candidate.import.apply',
         });
     }
-    return { applied, skipped };
+    return { applied: r.found, skipped: r.skipped };
 }
 async function requireCache(env) {
     if (!env.recruitContext)
@@ -582,7 +659,16 @@ const candidateImportPrepare = {
     handler: async (args, env) => {
         const cache = await requireCache(env);
         const plan = await buildImportPlan(env, cache, args);
-        const dup = await checkDuplicateByMobile(env, cache, plan.mobile);
+        // 标签预检（只读）+ 查重并行：让用户在确认摘要里就能看到哪些标签在本环境不存在（apply 会跳过它们）
+        const tagNames = Array.isArray(args.tags) ? args.tags.map(String).filter(Boolean) : [];
+        const [dup, tagCheck] = await Promise.all([
+            checkDuplicateByMobile(env, cache, plan.mobile),
+            tagNames.length
+                ? resolveTagIds(env, tagNames)
+                    .then((rt) => ({ requested: tagNames, found: rt.found, missing: rt.skipped }))
+                    .catch((error) => ({ requested: tagNames, missing: [], error: error?.message || '标签预检失败' }))
+                : Promise.resolve(null),
+        ]);
         if (dup.length > 1) {
             throw ehrValidationError('duplicate_ambiguous', `手机号 ${plan.mobile} 存在多条候选（数据异常），请人工核对后再决定，不自动新建`);
         }
@@ -621,6 +707,7 @@ const candidateImportPrepare = {
                 details: plan.details,
                 tags: Array.isArray(args.tags) ? args.tags : [],
             },
+            ...(tagCheck ? { tagCheck } : {}),
             continuation,
             expiresInSeconds: 600,
         });
@@ -684,43 +771,31 @@ const candidateImportApply = {
                 throw error;
             throw ehrPartialError(`简历建档写入结果不确定（${error?.message || '未知错误'}）：请先用人才库搜索手机号 ${payload.telephone} 核对是否已建档，禁止直接重试`, { candidateName: payload.candidateName, telephone: payload.telephone });
         }
-        // ③ 初始化人才批次（失败不回滚人才，仅记 warning）
-        let batchOk = null;
-        let batchNote;
-        try {
-            await env.host.request({
-                path: `/api/recruit/candidate/initTalentBatch?formDataId=${encodeURIComponent(talentId)}`,
-                method: 'POST',
-                operation: 'ehr.recruit.candidate.import.apply',
-            });
-            batchOk = true;
-        }
-        catch (error) {
-            batchOk = false;
-            batchNote = `人才已建档，但初始化人才批次失败：${error?.message || '未知错误'}（可在人才卡片手动处理）`;
-        }
-        // ④ 触发后台智能标签规则（规则未配置时不产生标签，属正常）
-        let labelMatch = null;
-        try {
-            const r = (await env.host.request({
-                path: `/api/recruit/label/matchTalentLabel?talentId=${encodeURIComponent(talentId)}`,
-                method: 'POST',
-                body: {},
-                operation: 'ehr.recruit.candidate.import.apply',
-            }));
-            labelMatch = r?.data === undefined ? 'TRIGGERED' : String(r.data);
-        }
-        catch {
-            labelMatch = 'FAILED（不影响建档，可稍后在人才卡片手动触发）';
-        }
-        // ⑤ 平台标签（按名命中清单写入，不存在则跳过）
-        let tagResult = { applied: [], skipped: [] };
-        try {
-            tagResult = await applyPlatformTags(env, talentId, Array.isArray(payload.tags) ? payload.tags.map(String) : []);
-        }
-        catch (error) {
-            tagResult = { applied: [], skipped: Array.isArray(payload.tags) ? payload.tags.map(String) : [] };
-        }
+        // ③④⑤ 初始化批次 / 触发电商后台标签规则 / 平台标签：三者只依赖 talentId，并行执行（各自 catch 等价原语义）
+        const batchTask = env.host
+            .request({
+            path: `/api/recruit/candidate/initTalentBatch?formDataId=${encodeURIComponent(talentId)}`,
+            method: 'POST',
+            operation: 'ehr.recruit.candidate.import.apply',
+        })
+            .then(() => ({ ok: true, note: undefined }))
+            .catch((error) => ({
+            ok: false,
+            note: `人才已建档，但初始化人才批次失败：${error?.message || '未知错误'}（可在人才卡片手动处理）`,
+        }));
+        const labelTask = env.host
+            .request({
+            path: `/api/recruit/label/matchTalentLabel?talentId=${encodeURIComponent(talentId)}`,
+            method: 'POST',
+            body: {},
+            operation: 'ehr.recruit.candidate.import.apply',
+        })
+            .then((r) => (r?.data === undefined ? 'TRIGGERED' : String(r.data)))
+            .catch(() => 'FAILED（不影响建档，可稍后在人才卡片手动触发）');
+        const tagTask = applyPlatformTags(env, talentId, Array.isArray(payload.tags) ? payload.tags.map(String) : []).catch(() => ({ applied: [], skipped: Array.isArray(payload.tags) ? payload.tags.map(String) : [] }));
+        const [batchOutcome, labelMatch, tagResult] = await Promise.all([batchTask, labelTask, tagTask]);
+        const batchOk = batchOutcome.ok;
+        const batchNote = batchOutcome.note;
         // ⑥ 产物链接：人才卡片单页 + 人才库列表定位（自用系统追加 recruitType=useSelf）
         const baseUrl = session.baseUrl.replace(/\/+$/, '');
         const extra = String(cache.selfUse) === '1' ? '&recruitType=useSelf' : '';

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

@@ -301,21 +301,28 @@ async function resolveCandidateForWrite(host, cache, talentId) {
         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({
+    // otherInfo 必成功（保持原语义）；baseInfo 并行取（姓名兜底 + AI 面试条件必填的邮箱/手机），失败不阻断
+    const [otherResponse, baseResponse] = await Promise.all([
+        host.request({
+            path: `/api/recruit/candidate/getCandidateCardOtherInfo?talentId=${talentId}&batchId=${batchId}&v=${v}&randomkey_ab=ab`,
+            headers: extra,
+        }),
+        host
+            .request({
             path: `/api/recruit/candidate/getCandidateCardBaseInfo?talentId=${talentId}&batchId=${batchId}&v=${v}&randomkey_cd=cd`,
             headers: extra,
-        }));
-        name = baseResponse?.data?.talent?.hrm?.name || '';
-    }
+        })
+            .catch(() => null),
+    ]);
+    const batch = otherResponse?.data?.currentCandidateBatch || {};
+    const talentBase = baseResponse?.data?.talent || {};
+    const name = batch?.talent?.name || talentBase?.hrm?.name || talentBase?.name || '';
+    const email = String(talentBase.email || talentBase.hrm?.email || '').trim();
+    const mobile = String(talentBase.telephone || talentBase.mobile || '').trim();
     return {
         name,
+        email,
+        mobile,
         candidateManageId: batch?.id || batch?.candidateManageId || null,
         positionId: batch?.position?.id || null,
         positionName: batch?.position?.name || null,
@@ -535,6 +542,8 @@ const candidateCreateApply = {
 // 安排面试 operation
 // ---------------------------------------------------------------------------
 const INTERVIEW_TYPES = ['现场面试', '视频面试', '电话面试', 'AI面试'];
+/** AI 面试方案默认值（用户口径：默认「大模型面试」）。若环境无此方案，运行时列出候选让用户选，绝不自动取第一条。 */
+const AI_DEFAULT_PLAN_NAME = '大模型面试';
 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() {
@@ -544,16 +553,181 @@ function defaultInterviewWindow() {
     const end = new Date(now.getTime() + 60 * 60 * 1000);
     return { start: fmt(now), end: fmt(end) };
 }
+/** 当前登录人（teamsCheck → currentUser.id/username）：面试官未指定时的默认值。
+ *  teamsCheck 响应无 status 字段、不被 isBusinessSuccess 认可，故直连 fetch 绕开业务判定（同 recruit.ts 口径）。 */
+async function resolveCurrentUserForWrite(host) {
+    try {
+        const session = await host.getSession();
+        const baseUrl = String(session?.baseUrl || '');
+        if (!baseUrl)
+            return null;
+        const resp = await fetch(`${baseUrl}/api/baseserver/layout/teamsCheck?clientType=not_xinchuang&client=WEB&domainName=${encodeURIComponent(baseUrl)}`, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                eteamsid: String(session?.eteamsId || ''),
+                cookie: typeof session?.cookieHeader === 'function' ? session.cookieHeader() : '',
+                'user-agent': typeof session?.uaHeader === 'function' ? session.uaHeader() : 'weaver-work-cli',
+                origin: baseUrl,
+            },
+            redirect: 'manual',
+        });
+        const data = await resp.json().catch(() => ({}));
+        const cu = data?.currentUser ?? data?.data?.currentUser ?? null;
+        if (!cu?.id)
+            return null;
+        return { id: String(cu.id), name: String(cu.username || cu.id) };
+    }
+    catch {
+        return null;
+    }
+}
+/** 取表单布局 id（GET 在低基线返 405 → 回退 POST），用于 AI 面试方案的关联字段候选 */
+async function fetchLayoutIdForForm(host, formId) {
+    try {
+        const r = (await host.request({
+            path: `/api/ebuilder/form/form/core/getFormLayout?formId=${encodeURIComponent(formId)}`,
+            method: 'GET',
+        }));
+        const id = r?.data?.formLayout?.id;
+        if (id)
+            return String(id);
+    }
+    catch {
+        // 低基线 GET 405 → POST
+    }
+    try {
+        const r = (await host.request({
+            path: '/api/ebuilder/form/form/core/getFormLayout',
+            method: 'POST',
+            body: { module: 'ebuilderform', formId, terminalType: 'PC' },
+        }));
+        const id = r?.data?.formLayout?.id;
+        if (id)
+            return String(id);
+    }
+    catch {
+        // 布局取不到时回退 formId（页面保存本身也回退 formId）
+    }
+    return formId;
+}
+const DIGITAL_PLAN_NAME_KEYS = ['msfa_name', 'digital_name', 'plan_name', 'scheme_name'];
+/** AI 面试方案（面试数字人）候选：① 关联字段候选接口 → ② 「面试数字人配置」列表兜底。
+ *  🔴 只返回候选，绝不自动取第一条（方案选错=面试由错误的数字人执行）。 */
+async function listDigitalPlansForWrite(host, cache, formId, layoutId, fieldId) {
+    try {
+        const r = (await host.request({
+            path: '/api/ebuilder/form/common/browser/complete/ebuilder',
+            body: {
+                browserMultiple: false,
+                newly: 1,
+                searchValue: '',
+                formParam: JSON.stringify({ formId, layoutId, fieldId, filterItems: [], module: 'ebuilderform', dataDetails: [] }),
+                openScroll: true,
+                controlId: fieldId,
+                businessId: formId,
+                variableMap: {},
+            },
+        }));
+        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() }));
+            if (items.length)
+                return { available: true, items };
+        }
+    }
+    catch {
+        // 回退列表
+    }
+    const menus = (cache.lists?.all_search || []);
+    const menu = menus.find((m) => (m.menuName || '').includes('面试数字人'))
+        || menus.find((m) => (m.menuName || '').includes('数字人配置'));
+    if (!menu?.listId) {
+        return { available: false, items: [], reason: '关联字段候选接口不可用，且当前环境未配置「面试数字人配置」列表菜单' };
+    }
+    let objId = '';
+    try {
+        const r = (await host.request({
+            path: `/api/ebuilder/form/obj/getObjsByTag?appId=${encodeURIComponent(String(cache.appId || ''))}&tag=uf_rcrt_digital_human`,
+            method: 'GET',
+        }));
+        const d = r?.data;
+        if (Array.isArray(d) && d.length)
+            objId = String(d[0]?.id || '');
+    }
+    catch {
+        // 取不到对象 id
+    }
+    if (!objId)
+        return { available: false, items: [], reason: '未能解析「面试数字人配置」对象 id' };
+    const rows = [];
+    for (let cur = 1; cur <= 20; cur++) {
+        const r = (await host.request({
+            path: `/api/ebuilder/form/list/getListDatas?passid=${objId}&cid=${objId}`,
+            body: {
+                current: cur,
+                pageSize: 100,
+                tableuid: randomHex32(),
+                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,
+            },
+            headers: { ebBusinessId: String(menu.listId) },
+        }));
+        const page = r?.data?.data || [];
+        rows.push(...page);
+        if (page.length < 100)
+            break;
+    }
+    const items = rows
+        .map((x) => {
+        const nk = DIGITAL_PLAN_NAME_KEYS.find((k) => String(x[k] || '').trim());
+        return { id: String(x.form_data_id || x.id || ''), name: String(nk ? x[nk] : '').trim() };
+    })
+        .filter((x) => x.id);
+    if (!items.length)
+        return { available: false, items: [], reason: '「面试数字人配置」暂无可选方案' };
+    return { available: true, items };
+}
+/** 方案匹配：id 全等 → 名称全等 → 名称包含（唯一才算命中，否则回歧义列表） */
+function pickDigitalPlanForWrite(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 };
+}
 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 isAI = type === 'AI面试';
     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;
@@ -582,9 +756,63 @@ async function buildInterviewPlan(env, cache, args) {
     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 interviewerInput = typeof args.interviewer === 'string' ? args.interviewer.trim() : '';
+    let interviewerId = null;
+    let interviewer = interviewerInput;
+    if (interviewerInput) {
+        interviewerId = await resolvePersonId(host, fieldIdOf('interviewer'), interviewerInput);
+        if (!interviewerId) {
+            throw ehrValidationError('interviewer_not_found', `面试官「${interviewerInput}」解析不到 userId（browser/complete/resource 无匹配）`);
+        }
+    }
+    else {
+        const me = await resolveCurrentUserForWrite(host);
+        if (!me) {
+            throw ehrValidationError('interviewer_unresolved', '未指定面试官，且无法解析当前登录人（teamsCheck 失败）；请用 interviewer 参数指定');
+        }
+        // 🔴 teamsCheck 的 currentUser.id 与人员字段 optionId 语义未必相同（实测两者 id 不同），
+        // 故用与显式指定完全相同的解析通道（browser/complete/resource）把姓名换成 userId。
+        interviewerId = await resolvePersonId(host, fieldIdOf('interviewer'), me.name);
+        if (!interviewerId) {
+            throw ehrValidationError('interviewer_unresolved', `未指定面试官，当前登录人「${me.name}」在人员字段中解析不到；请用 interviewer 参数指定`);
+        }
+        interviewer = me.name;
+    }
+    // AI 面试：方案（digital_id）与邮箱都是条件必填，不填保存必失败
+    let aiPlan = null;
+    let aiPlans = [];
+    let email = String(args.email || '').trim() || candidate.email;
+    const mobile = candidate.mobile;
+    if (isAI) {
+        const digitalFid = fieldIdOf('digital_id');
+        if (!digitalFid) {
+            throw ehrValidationError('recruit_field_missing', '面试计划表单缺少「AI面试方案」字段（digital_id），无法安排 AI 面试');
+        }
+        const layoutId = await fetchLayoutIdForForm(host, formId);
+        const plans = await listDigitalPlansForWrite(host, cache, formId, layoutId, digitalFid);
+        aiPlans = plans.items;
+        if (!plans.available) {
+            throw ehrValidationError('ai_plan_unavailable', `AI 面试必须选择「AI面试方案」，但${plans.reason || '暂无可选方案'}；请先在该环境维护「面试数字人配置」`);
+        }
+        // 默认「大模型面试」（用户口径）；环境无此方案时列出候选，绝不自动取第一条
+        const wanted = typeof args.aiPlan === 'string' && args.aiPlan.trim() ? args.aiPlan.trim() : AI_DEFAULT_PLAN_NAME;
+        const picked = pickDigitalPlanForWrite(aiPlans, wanted);
+        if (picked.plan) {
+            aiPlan = picked.plan;
+        }
+        else if (picked.ambiguous.length > 1) {
+            throw ehrValidationError('ai_plan_ambiguous', `AI面试方案「${wanted}」命中多个：${picked.ambiguous.map((x) => x.name).join('、')}，请用 aiPlan 指明具体方案`, { candidates: picked.ambiguous });
+        }
+        else {
+            throw ehrValidationError('ai_plan_not_found', `未找到 AI面试方案「${wanted}」，请用 aiPlan 从候选中指定（候选：${aiPlans.map((x) => x.name).join('、')}）`, { candidates: aiPlans });
+        }
+        if (!email) {
+            throw ehrValidationError('email_required', 'AI 面试要求填写候选人邮箱：人才资料里没有邮箱，请用 email 参数提供');
+        }
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+            throw ehrValidationError('email_invalid', `候选人邮箱格式不正确：${email}`);
+        }
     }
     const window = defaultInterviewWindow();
     const start = typeof args.startTime === 'string' && args.startTime.trim() ? args.startTime.trim() : window.start;
@@ -603,6 +831,9 @@ async function buildInterviewPlan(env, cache, args) {
         { 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 }] },
+        ...(mobile ? [{ formField: { id: fieldIdOf('mobile') }, content: mobile }] : []),
+        ...(email ? [{ formField: { id: fieldIdOf('email') }, content: email }] : []),
+        ...(aiPlan ? [{ formField: { id: fieldIdOf('digital_id') }, dataOptions: [{ optionId: aiPlan.id, content: aiPlan.name }] }] : []),
     ];
     return {
         formId, objId, dataDetails,
@@ -610,12 +841,19 @@ async function buildInterviewPlan(env, cache, args) {
         positionName: candidate.positionName,
         interviewTime: `${start} ~ ${end}`,
         interviewer,
+        email: email || undefined,
+        mobile: mobile || undefined,
+        isAIInterview: isAI,
+        aiPlan,
+        aiPlans: isAI ? aiPlans : undefined,
     };
 }
 const interviewArrangeSchema = {
     talentId: { type: 'string', pattern: '^\\d+$', description: '人才 ID（candidate.search 返回的 talentId）' },
-    interviewer: { type: 'string', description: '面试官姓名（须可解析为系统人员）' },
+    interviewer: { type: 'string', description: '面试官姓名（可选；不填默认当前登录人）' },
     type: { type: 'string', enum: [...INTERVIEW_TYPES], description: '面试方式，默认现场面试' },
+    aiPlan: { type: 'string', description: 'AI 面试方案（方案名或 id；type=AI面试 时生效，默认「大模型面试」）' },
+    email: { type: 'string', description: '候选人邮箱（AI 面试必填；不填则取人才资料里的邮箱）' },
     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，默认当前时间' },
@@ -631,7 +869,7 @@ const interviewArrangePrepare = {
     capability: 'recruit',
     risk: WRITE,
     requiresConfirmation: true,
-    inputSchema: schemaOf({ ...interviewArrangeSchema }, { required: ['talentId', 'interviewer'] }),
+    inputSchema: schemaOf({ ...interviewArrangeSchema }, { required: ['talentId'] }),
     handler: async (args, env) => {
         const cache = await requireRecruitCache(env);
         const plan = await buildInterviewPlan(env, cache, args);
@@ -656,6 +894,13 @@ const interviewArrangePrepare = {
                 session: args.session || '初试',
                 time: plan.interviewTime,
                 interviewer: plan.interviewer,
+                ...(plan.isAIInterview
+                    ? {
+                        aiPlan: plan.aiPlan ? `${plan.aiPlan.name}（id=${plan.aiPlan.id}）` : '(未指定)',
+                        email: plan.email || '(缺失)',
+                        mobile: plan.mobile || '(人才资料无手机号)',
+                    }
+                    : {}),
                 notify: notify ? '将触发「新建日程」面试通知动作流（外部通知）' : '面试通知默认不触发',
             },
             willSubmit: { formId: plan.formId, objId: plan.objId, dataDetails: plan.dataDetails },

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

@@ -15,6 +15,8 @@ import { compact, normalizePaged, toNumber, toPageQuery, toPositiveInt } from '.
 // ─────────────────────────────────────────────────────────────────────────────
 const RECRUIT_APP_TAG = 'weaver-recruit-service';
 /** 逻辑名 -> objTag（权威映射，与 _init_env_cache.mjs 一致） */
+/** 环境缓存结构版本：新增/变更解析字段（如 2026-11-04 补 candidate 应聘者列表）时 +1，旧缓存自动失效重建。 */
+const RECRUIT_CACHE_VERSION = 1;
 const RECRUIT_TAGS = {
     talent_pool: 'uf_rcrt_talent_pool',
     interview_plan: 'uf_rcrt_interview_plan',
@@ -38,7 +40,8 @@ const LIST_KEYWORDS = {
     position: ['招聘职位', '职位列表', '职位管理'],
     entry: ['入职管理'],
     offer: ['录用管理', 'offer管理', 'offer'],
-    interview: ['面试管理'],
+    interview: ['面试管理', '面试安排列表', '面试安排'],
+    candidate: ['应聘者', '候选人', '应聘批次', '应聘管理'],
     biz_config: ['业务配置映射表'],
 };
 /** 列表类型 -> 缓存键 + 表单逻辑名（candidate.list 四列表映射，同 recruit-list.mjs TYPES） */
@@ -47,6 +50,8 @@ export const LIST_TYPES = {
     position: { listKey: 'position', formType: 'position_manage', title: '招聘职位' },
     entry: { listKey: 'entry', formType: 'entry_manage', title: '入职管理' },
     offer: { listKey: 'offer', formType: 'offer', title: '录用管理' },
+    interview: { listKey: 'interview', formType: 'interview_plan', title: '面试管理' },
+    candidate: { listKey: 'candidate', formType: 'candidate_manage', title: '应聘者' },
 };
 /** 剔除与展示无关的内部键（同 recruit-list.mjs） */
 const INTERNAL_KEYS = new Set([
@@ -336,7 +341,7 @@ async function resolveRecruitEnv(host, appId) {
     }
     const lists = {
         talent: null, demand: null, position: null, entry: null, offer: null,
-        interview: null, dict: dictMenu, biz_config: bizConfigMenu,
+        interview: null, candidate: null, dict: dictMenu, biz_config: bizConfigMenu,
         all_search: searchMenus, pages,
     };
     for (const [biz, keywords] of Object.entries(LIST_KEYWORDS)) {
@@ -384,7 +389,7 @@ export function createRecruitContextLoader() {
             }
         }
         catch { /* 缓存读取失败回退闸门链路 */ }
-        if (diskCache) {
+        if (diskCache && diskCache.cacheVersion === RECRUIT_CACHE_VERSION) {
             memo.set(memoKey, diskCache);
             return diskCache;
         }
@@ -409,6 +414,7 @@ export function createRecruitContextLoader() {
                     note: 'recruit-ops 环境参数缓存（weaver-work-cli 运行时解析产物，不含认证字段）',
                 },
                 envKey: `${dir.split(/[\\/]/).pop()}|${appId}`,
+                cacheVersion: RECRUIT_CACHE_VERSION,
                 ...resolved,
             }, null, 2), 'utf8');
         }
@@ -627,7 +633,7 @@ const candidateList = {
     capability: 'recruit',
     risk: READ,
     inputSchema: schemaOf({
-        type: { type: 'string', enum: ['demand', 'position', 'entry', 'offer'], description: '列表类型' },
+        type: { type: 'string', enum: ['demand', 'position', 'entry', 'offer', 'interview', 'candidate'], description: '列表类型' },
         current: SCHEMA_ID,
         pageSize: SCHEMA_ID,
     }, { required: ['type'] }),