weaver-work-cli 0.1.40 → 0.1.44

package/dist/shortcuts/recruit-stage/operations/resume-import.js

@@ -0,0 +1,1354 @@
+/**
+ * recruit-stage.resume.import.* —— 简历导入建人才（自 recruit-resume-import.mjs 1:1 移植）
+ *
+ * 三种输入（优先级：structured > fileId > resumeFile）：
+ * - structured：大模型按 §13 schema 整理好的结构化简历对象（解析主通道；字典类字段给名称时
+ *   按数据字典唯一命中反查 optionId，歧义/缺失跳过，绝不写脏值）
+ * - fileId：已上传到 E10 的简历附件 id（原件仍会写进附件字段）
+ * - resumeFile：本地简历路径（两步 multipart 上传后同上）
+ * OCR 兜底（useOcr:true）仅显式开启时调用（闸门 = checkResumeExtraction）；checkRpaValid 已废弃。
+ *
+ * 链路：查重（两级：getCandidateByPhone 页面同款 + checkUnique 表单唯一性，含软删除占用）
+ *   → 建人才（首选 dataset/v2 主表+明细一次写入；被拦时回退 form/core 主表 + dataset update 补明细）
+ *   → initTalentBatch 初始化批次 → matchTalentLabel 触发规则匹配 → 平台标签写入（含学校归属自动推导）
+ *   → 读回校验明细行数 → 人才卡片/人才库定位双链接。
+ *
+ * 更新已有人才（updateTalentId）：主表全量覆盖 + 明细整表覆盖（仅覆盖解析出数据的表），
+ * 受保护字段（is_blacklist/recruit_status/candidate_status/data_status）不覆盖，prepare 先出差异。
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import schoolTiers from '../school-tiers.json';
+import { rsSuccess, schemaOf } from './types.js';
+import { rsFail, rsValidationError, rsConfirmationError } from '../errors.js';
+import { objIdOf, formIdOf, saveFormData, getFormLayoutMeta, runSaveButtonEsbActions, getTableMapping, invertTableMapping, datasetSaveFormData, datasetUpdateFormData, checkUnique, getCandidateByPhone, buildCardUrl, buildTalentViewUrl, talentLinkExtra, findMenuNode, randHex32, } from '../shared.js';
+// 更新时不允许简历覆盖的字段（人工判定/流程状态，简历无权改写）
+const PROTECTED_UPDATE_KEYS = ['is_blacklist', 'recruit_status', 'candidate_status', 'data_status'];
+// ── 上传简历文件（两步：preUploadCheck 取 preUploadId → module/upload 带 file）→ fileid ──
+// ⚠️ 预上传检查必须带文件，否则服务端 500；正式上传必带 name/MD5/lastModified/lastModifiedDate。
+async function uploadResume(host, baseUrl, filePath, fieldId, formId) {
+    const buf = fs.readFileSync(filePath);
+    const filename = path.basename(filePath);
+    const baseForm = () => {
+        const fd = new FormData();
+        fd.append('compressImg', 'false');
+        fd.append('source', 'form');
+        fd.append('fieldId', fieldId);
+        fd.append('sourceRefId', formId);
+        fd.append('module', 'ebuilderform');
+        fd.append('authModule', 'ebuilderform');
+        fd.append('formId', formId);
+        fd.append('refId', formId);
+        fd.append('size', String(buf.length));
+        fd.append('commonText', JSON.stringify({ fieldId, formId }));
+        return fd;
+    };
+    const headers = {
+        langType: 'zh_CN', timeZoneOffset: '-480', ebBusinessId: formId,
+        Accept: 'application/json, text/plain, */*',
+        'X-Requested-With': 'XMLHttpRequest',
+    };
+    const withFile = () => { const fd = baseForm(); fd.append('file', new Blob([buf]), filename); return fd; };
+    const c = await host.request({ path: '/api/file/preUploadCheck', method: 'POST', multipart: withFile(), headers });
+    const preUploadId = c?.data?.preUploadId;
+    const uploadType = c?.data?.uploadType || 'common';
+    if (!preUploadId)
+        throw rsFail('简历预上传检查失败：' + JSON.stringify(c || {}).slice(0, 200));
+    const fd = baseForm();
+    const md5 = createHash('md5').update(buf).digest('hex');
+    const lm = String(Math.round(fs.statSync(filePath).mtimeMs || Date.now()));
+    fd.append('name', filename);
+    fd.append('MD5', md5);
+    fd.append('lastModified', lm);
+    fd.append('lastModifiedDate', lm);
+    fd.append('preUploadId', String(preUploadId));
+    fd.append('uploadType', String(uploadType));
+    fd.append('file', new Blob([buf]), filename);
+    const j = await host.request({ path: '/api/file/module/upload', method: 'POST', multipart: fd, headers });
+    if (!j?.data?.fileid)
+        throw rsFail('简历上传失败：' + JSON.stringify(j || {}).slice(0, 200));
+    return { fileid: String(j.data.fileid), name: j.data.name || filename };
+}
+// OCR 兜底解析（仅显式 useOcr 才调用）：唯一闸门 = checkResumeExtraction
+async function extractResume(host, fileid) {
+    const b = await host.request({ path: '/api/recruit/ocr/checkResumeExtraction', method: 'POST', body: {} });
+    if (b?.data !== true)
+        throw rsFail('当前环境未开启简历抽取（checkResumeExtraction=false）：OCR 兜底不可用，请由大模型解析后走 structured 输入');
+    const r = await host.request({ path: '/api/recruit/ocr/resumeExtraction?fileId=' + encodeURIComponent(fileid), method: 'POST' });
+    const d = r?.data?.data;
+    if (!d || typeof d !== 'object')
+        throw rsFail('未从文件中解析出简历信息（可能是非简历文件）');
+    return d;
+}
+// 解析结果 → 人才基本信息 dataDetails（文本 content / 字典 dataOptions / 长文本 dataText）
+function mapToTalent(fields, s) {
+    const out = [];
+    const put = (k, val, opts) => {
+        if (val === undefined || val === null || val === '')
+            return;
+        const id = fields[k];
+        if (!id)
+            return; // 环境无该字段则跳过，不臆造
+        out.push(opts ? { formField: { id }, dataOptions: opts } : { formField: { id }, content: String(val) });
+    };
+    const putLong = (k, val) => {
+        if (val === undefined || val === null || val === '')
+            return;
+        const id = fields[k];
+        if (!id)
+            return;
+        out.push({ formField: { id }, dataText: { content: String(val) } });
+    };
+    put('candidate_name', s.candidateName);
+    put('telephone', s.telephone);
+    put('email', s.email);
+    if (s.gender)
+        put('gender', s.genderName || s.gender, [{ optionId: String(s.gender), content: s.genderName || String(s.gender) }]);
+    put('birthday', s.birthday);
+    put('age', s.age);
+    if (s.highest_degree)
+        put('highest_degree', s.highest_degree_name || s.highest_degree, [{ optionId: String(s.highest_degree), content: s.highest_degree_name || String(s.highest_degree) }]);
+    // highest_degree_new 解析常给「序号」（如 3），不是 optionId → 只接受长数字 id，避免写脏值
+    if (/^\d{6,}$/.test(String(s.highest_degree_new || '')))
+        put('highest_degree_new', s.highest_degree_new);
+    put('college', s.college);
+    put('joinworkdate', s.joinworkdate);
+    put('graduate_date', s.graduate_date);
+    put('intend_position', s.intend_position);
+    put('intended_workplace', s.intended_workplace);
+    putLong('self_desc', s.self_desc);
+    putLong('work_ability', s.work_ability);
+    const job0 = Array.isArray(s.jobInformations) ? s.jobInformations[0] : null;
+    if (job0) {
+        put('current_position', job0.work_position);
+        put('current_industry', job0.co_name);
+    }
+    return out;
+}
+// dataDetails（formField.id 口径）→ 数据集接口 mainTable（dataKey 口径；键必须用 config.dataKey）
+function toDatasetMainTable(dataDetails, fields) {
+    const rev = {};
+    for (const [dk, fid] of Object.entries(fields || {}))
+        rev[String(fid)] = dk;
+    const out = {};
+    for (const d of dataDetails || []) {
+        const dk = rev[String(d?.formField?.id || '')];
+        if (!dk)
+            continue;
+        let v;
+        if (Array.isArray(d.dataOptions)) {
+            const o = d.dataOptions[0] || {};
+            v = o.optionId !== undefined && o.optionId !== '' ? String(o.optionId) : String(o.content || '');
+        }
+        else if (d.dataText) {
+            v = String(d.dataText.content ?? '');
+        }
+        else if (d.content !== undefined) {
+            v = String(d.content);
+        }
+        else
+            continue;
+        if (v === '')
+            continue;
+        out[dk] = v;
+    }
+    return out;
+}
+// 明细表元数据：全部从表单布局运行时解析（DetailTable config.subFormId + 列组件 config.fieldId），不写死
+async function resolveSubTableMeta(ctx) {
+    const formId = formIdOf(ctx.cache, 'talent_pool');
+    const meta = await getFormLayoutMeta(ctx.host, formId);
+    const comps = meta?.formLayout?.pageLayouts?.[0]?.comps || [];
+    const tables = [];
+    for (const c of comps) {
+        const cfg = c.config || {};
+        if (c.type === 'DetailTable' && cfg.dataKey && cfg.subFormId) {
+            tables.push({ dataKey: String(cfg.dataKey), subFormId: String(cfg.subFormId), title: String(cfg.title || '') });
+        }
+    }
+    const out = {};
+    for (const t of tables) {
+        const cols = {};
+        for (const c of comps) {
+            const cfg = c.config || {};
+            if (String(cfg.subFormId) !== t.subFormId)
+                continue;
+            if (!cfg.dataKey || !cfg.fieldId)
+                continue;
+            const col = { id: String(cfg.fieldId), type: String(c.type || ''), title: String(cfg.title || '') };
+            // 日期区间（DateRange/DateInterval）：物理上是两个子字段，各有独立 dataKey；不写死命名规律，按布局取
+            if (cfg.start && cfg.end && cfg.start.dataKey && cfg.end.dataKey) {
+                col.startKey = String(cfg.start.dataKey);
+                col.endKey = String(cfg.end.dataKey);
+            }
+            cols[String(cfg.dataKey)] = col;
+        }
+        out[t.dataKey] = { ...t, columns: cols };
+    }
+    return out;
+}
+// 字典 id → 名称
+function makeDictLookup(cache) {
+    const byId = new Map();
+    for (const x of cache.dict?.raw || []) {
+        if (x.option_id && x.selection_name)
+            byId.set(String(x.option_id), x.selection_name);
+    }
+    return (id) => byId.get(String(id)) || '';
+}
+// 结构化简历 → 明细表行（值一律标量；关联/选择类解析给字典 id → 反查名称确认存在，查不到跳过不写脏值）
+function buildSubDetails(structured, subs, cache) {
+    const byTable = {};
+    const stats = {};
+    const dictName = makeDictLookup(cache);
+    const addRows = (dataKey, rows, fieldMap) => {
+        const sub = subs[dataKey];
+        if (!sub || !Array.isArray(rows) || !rows.length)
+            return 0;
+        const list = [];
+        for (const r of rows) {
+            if (!r || typeof r !== 'object')
+                continue;
+            const row = {};
+            for (const [dk, conv] of Object.entries(fieldMap)) {
+                const col = sub.columns[dk];
+                if (!col)
+                    continue;
+                const v = conv(r);
+                if (v === undefined || v === null || v === '')
+                    continue;
+                // 日期区间：一个组件 = 两个物理字段（start/end 各有 dataKey），必须拆成两键提交
+                if (col.startKey && col.endKey) {
+                    const parts = Array.isArray(v) ? v : String(v).split(/[,~]/);
+                    const s = String(parts[0] || '').trim();
+                    const e = String(parts[1] || '').trim();
+                    // 「至今」的岗位/项目只有开始日期（实测 2026-11-05：原逻辑一旦缺 end 就整行跳过，
+                    // 导致在职经历的起始日期丢失）。有哪个写哪个，两者都空才跳过。
+                    if (s)
+                        row[col.startKey] = s;
+                    if (e)
+                        row[col.endKey] = e;
+                    if (!s && !e)
+                        continue;
+                    continue;
+                }
+                const scalar = typeof v === 'object' ? String(v.optionId ?? v.content ?? '') : String(v);
+                if (scalar === '')
+                    continue;
+                row[dk] = scalar;
+            }
+            if (Object.keys(row).length)
+                list.push(row);
+        }
+        if (list.length)
+            byTable[dataKey] = list;
+        return list.length;
+    };
+    const dictOpt = (id) => {
+        if (id === undefined || id === null || id === '')
+            return '';
+        const s = String(id).trim();
+        return dictName(s) ? s : '';
+    };
+    const selOpt = (v) => {
+        if (!v)
+            return '';
+        const s = String(v).trim();
+        return /^\d{6,}$/.test(s) ? dictOpt(s) : '';
+    };
+    stats.rcrt_education_exp = addRows('rcrt_education_exp', structured.academicInformations, {
+        school: (r) => r.school,
+        edu_major: (r) => r.edu_major,
+        edu_education: (r) => dictOpt(r.edu_education),
+        degree: (r) => selOpt(r.degree),
+        study_date: (r) => r.study_date,
+        faculty: (r) => r.faculty,
+        research_direction: (r) => r.research_direction,
+        major_courses: (r) => r.major_courses,
+    });
+    stats.rcrt_work_exp = addRows('rcrt_work_exp', structured.jobInformations || structured.workExperiences, {
+        co_name: (r) => r.co_name || r.company,
+        work_position: (r) => r.work_position || r.position,
+        work_dept: (r) => r.work_dept || r.department,
+        work_desc: (r) => r.job_description || r.work_desc,
+        resign_cause: (r) => r.resign_cause,
+        start_end_date: (r) => [r.start_date, r.end_date].filter(Boolean).join(',') || r.work_date,
+        work_type: (r) => selOpt(r.work_type),
+    });
+    stats.rcrt_sxjl = addRows('rcrt_sxjl', structured.internshipExperiences, {
+        sx_co_name: (r) => r.sx_co_name,
+        position_job: (r) => r.position_job,
+        job_description: (r) => r.job_description,
+        entry_time: (r) => r.entry_time,
+        sx_work_type: (r) => selOpt(r.sx_work_type),
+    });
+    stats.rcrt_project_exp = addRows('rcrt_project_exp', structured.projectExperiences, {
+        pj_name: (r) => r.pj_name || r.project_name,
+        pj_role: (r) => r.pj_role,
+        pj_duty: (r) => r.pj_duty,
+        pj_introduction: (r) => r.pj_introduction || r.project_description,
+        pj_date: (r) => [r.start_date, r.end_date].filter(Boolean).join(','),
+    });
+    stats.rcrt_award_exp = addRows('rcrt_award_exp', structured.awardExperiences, {
+        award_name: (r) => r.award_name,
+        awarded: (r) => r.awarded,
+        credentials: (r) => r.credentials,
+        award_date: (r) => r.award_date,
+    });
+    stats.rcrt_language_skill = addRows('rcrt_language_skill', structured.languageAbilities, {
+        language_type: (r) => r.language_type,
+        mastery: (r) => selOpt(r.mastery),
+        ls_ability: (r) => selOpt(r.ls_ability),
+        literacy: (r) => selOpt(r.literacy),
+    });
+    return { byTable, stats };
+}
+// 读记录简要（查重结果展示用）：主表 name/mobile/email/college
+function makeBriefReader(ctx, formId, objId, fields) {
+    const rev = {};
+    for (const [dk, fid] of Object.entries(fields || {}))
+        rev[String(fid)] = dk;
+    return async (dataId) => {
+        try {
+            const r = await ctx.host.request({
+                path: '/api/ebuilder/form/form/core/getFormDataAndLayout', method: 'POST',
+                body: {
+                    terminalType: 'PC', dataId, formId, module: 'ebuilderform', newLayout: true,
+                    dataCrossLayout: false, permissionId: '', allReadOnly: true, initialDatas: [],
+                    dynamicData: false, cost: false, customParam: { objId, dataId },
+                },
+            });
+            const fd = r?.data?.formData;
+            if (!fd)
+                return null;
+            const dets = fd.dataDetails || [];
+            const get = (dk) => {
+                const d = dets.find((x) => rev[String(x.fieldId)] === dk);
+                if (!d)
+                    return '';
+                return String(d.content ?? (d.dataText || {}).content ?? (d.dataOptions || []).map((o) => o.content).join(',') ?? '');
+            };
+            return { name: get('candidate_name'), mobile: get('telephone'), email: get('email'), college: get('college') };
+        }
+        catch {
+            return null;
+        }
+    };
+}
+// 人才卡片 URL（环境缓存 ebdDetailPageId；自用系统追加 recruitType=useSelf）
+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)}`;
+}
+// 人才库列表并打开指定人才：{baseUrl}/sp/ebdfpage/list/{listId}?talentId={id}&recruitType=useSelf
+function resolveTalentListLocateUrl(ctx, talentId) {
+    const listId = ctx.cache.lists?.talent?.listId;
+    if (!listId || !talentId)
+        return null;
+    return `${ctx.baseUrl}/sp/ebdfpage/list/${listId}?talentId=${talentId}${talentLinkExtra(ctx.cache)}`;
+}
+// 读记录快照（更新前算 diff）：主表 {dataKey: 展示值} + 各子表行数/格数
+async function readTalentSnapshot(ctx, opts) {
+    const { host, formId, objId, fields, subMeta, dataId } = opts;
+    const L = await getFormLayoutMeta(ctx.host, formId);
+    const r = await ctx.host.request({
+        path: '/api/ebuilder/form/form/core/getFormDataAndLayout', method: 'POST',
+        body: {
+            terminalType: 'PC', dataId, formId, module: 'ebuilderform', newLayout: true,
+            layoutId: L?.formLayout?.id, layoutMultiId: L?.formLayoutMultiple?.id, dataCrossLayout: false,
+            permissionId: '', allReadOnly: true, initialDatas: [], dynamicData: false, cost: false,
+            customParam: { objId, dataId },
+        },
+    });
+    const dets = r?.data?.formData?.dataDetails || [];
+    const rev = {};
+    for (const [dk, fid] of Object.entries(fields || {}))
+        rev[String(fid)] = dk;
+    // 取值顺序：dataOptions.content > dataText.content > content（关联/选择字段 content 常为空，先取会误判）
+    const valOf = (d) => {
+        const opt = (d.dataOptions || []).map((o) => o.content).filter(Boolean).join(',');
+        const txt = (d.dataText || {}).content || '';
+        return opt || txt || (d.content ?? '');
+    };
+    const main = {};
+    const subRows = {};
+    const subCells = {};
+    const subIdToKey = {};
+    for (const [dk, sub] of Object.entries(subMeta || {}))
+        subIdToKey[String(sub.subFormId)] = dk;
+    const seen = {};
+    for (const d of dets) {
+        const subId = d.subFormId ? String(d.subFormId) : '';
+        if (subId) {
+            const dk = subIdToKey[subId] || subId;
+            (seen[dk] = seen[dk] || new Set()).add(String(d.dataIndex));
+            subCells[dk] = (subCells[dk] || 0) + 1;
+            continue;
+        }
+        const dk = rev[String(d.fieldId)];
+        if (dk)
+            main[dk] = String(valOf(d));
+    }
+    for (const [dk, s] of Object.entries(seen))
+        subRows[dk] = s.size;
+    return { main, subRows, subCells };
+}
+// ── 标签链路 ──
+// a) 触发后台「人才自动标签」规则匹配（talentId 走 query，body 为空）
+async function matchTalentLabel(host, talentId) {
+    const r = await host.request({ path: '/api/recruit/label/matchTalentLabel?talentId=' + encodeURIComponent(talentId), method: 'POST', body: {} });
+    return r?.data || null;
+}
+// b) 平台标签清单（公共 type0 / 个人 type1），运行时分页拉全——标签 id 各环境不同，绝不写死
+// ── 平台标签清单：磁盘缓存（TTL 24h）+ 首轮取总页数后并发翻页 ──
+// 背景（2026-11-04 实测 www.e-cology.com.cn）：平台标签 **1924 个**，原实现「每类逐页串行 + 跨 type 累计
+// total 判定」需 20+ 次串行请求 ≈ 20s，是简历链路最大瓶颈（不带标签 7.77s → 带标签 28.09s）。
+// 标签属低频变更数据 → 磁盘缓存（24h）+ 并发翻页（限 5）后：首次 ~1-2s、后续 0 请求。
+// ── 平台标签解析：按名精确查询优先，服务端未过滤时回退全量并发（不落盘）──
+// 背景（2026-11-04 实测 www.e-cology.com.cn）：平台标签 1924 个、绝大部分与招聘无关；
+// 原「全量分页 + 磁盘缓存」在网页版小E 沙箱（容器不持久、盘可能只读）无收益，且缓存无用户维度
+// （个人标签存在跨用户读取风险）。现改为：按名逐个并发查询（N 个标签 → 1 轮请求），
+// 仅当确认服务端未按名过滤时才回退「全量并发翻页」，**不做磁盘缓存**。
+/** 单名查询：并行 type0/type1；filtered=false 表示该 type 返回满页且 total 很大（疑似未按名过滤） */
+async function queryTagByName(host, 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) => host.request({ path: '/api/my/tag/query', method: 'POST', body: bodyOf(type) }).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 };
+}
+// 单个 type 的全量标签：第 1 页拿 total → 剩余页按批并发（每批 5，上限 40 页防失控）
+async function fetchTagsOfType(host, type) {
+    const pageSize = 100;
+    const bodyOf = (pageNo) => ({ type, name: '', order: 8, pageSize, pageNo, search: 1, tagGroup: 0, tagModules: ['ebuilderform'] });
+    const first = await host.request({ path: '/api/my/tag/query', method: 'POST', body: bodyOf(1) }).catch(() => null);
+    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) => host.request({ path: '/api/my/tag/query', method: 'POST', body: bodyOf(p) }).catch(() => null)));
+            for (const r of rs) {
+                const list = r?.data?.data;
+                if (Array.isArray(list))
+                    rows.push(...list);
+            }
+        }
+    }
+    return rows;
+}
+async function listPlatformTags(host) {
+    const all = [];
+    for (const type of [0, 1]) {
+        try {
+            all.push(...await fetchTagsOfType(host, type));
+        }
+        catch { /* 单类型失败不影响另一类 */ }
+    }
+    const seen = new Set();
+    return all.filter((t) => t && t.tagId && !seen.has(String(t.tagId)) && seen.add(String(t.tagId)));
+}
+// 按名解析 → tagId（不存在进 missing，不臆造；同名优先公共标签）
+// 默认场景（简历导入）names 通常只有 1~4 个学校标签 → 1 轮并发按名查询即可；用户显式要求时才扩到其他标签。
+async function resolveTags(host, names) {
+    const norm = (s) => String(s == null ? '' : s).trim().toLowerCase();
+    const byName = new Map();
+    const uniqNames = [...new Set((names || []).map((n) => String(n)).filter(Boolean))];
+    let availableCount;
+    if (!uniqNames.length)
+        return { resolved: [], found: [], missing: [], available: [], availableCount };
+    // ① 按名并发查询（N 个名字 → 1 轮）
+    const probes = await Promise.all(uniqNames.map((n) => queryTagByName(host, n).catch(() => ({ items: [], filtered: true }))));
+    const nameQueryUsable = probes.every((p) => p.filtered);
+    if (nameQueryUsable) {
+        for (const p of probes) {
+            for (const t of p.items) {
+                if (!t || !t.tagId)
+                    continue;
+                const k = norm(t.name);
+                const prev = byName.get(k);
+                if (!prev)
+                    byName.set(k, t);
+                else if ((prev.type ?? 0) !== 0 && t.type === 0)
+                    byName.set(k, t);
+            }
+        }
+    }
+    else {
+        // ② 回退：服务端疑似未按名过滤 → 全量并发（不落盘）
+        const dict = await listPlatformTags(host);
+        availableCount = dict.length;
+        for (const t of dict) {
+            const k = norm(t.name);
+            const prev = byName.get(k);
+            if (!prev)
+                byName.set(k, t);
+            else if ((prev.type ?? 0) !== 0 && t.type === 0)
+                byName.set(k, t);
+        }
+    }
+    const resolved = [];
+    const found = [];
+    const missing = [];
+    for (const n of names || []) {
+        const t = byName.get(norm(n));
+        if (!t) {
+            missing.push(n);
+            continue;
+        }
+        resolved.push({ id: String(t.tagId), name: t.name, type: t.type ?? 0 });
+        found.push(t.name);
+    }
+    return {
+        resolved, found, missing, availableCount,
+        available: [...byName.values()].map((t) => ({ tagId: String(t.tagId), name: t.name, type: t.type ?? 0 })),
+    };
+}
+// c) 写入实体标签（先确认存在再写；不存在不写）
+async function addEntityTags(host, talentId, names) {
+    if (!names || !names.length)
+        return { applied: [], skipped: [] };
+    const { resolved, found, missing } = await resolveTags(host, names);
+    if (!resolved.length)
+        return { applied: [], skipped: missing };
+    const r = await host.request({
+        path: '/api/my/tag/common/batchAddEntityTag', method: 'POST',
+        body: { tags: resolved, batchDatas: [{ entityId: String(talentId), module: 'ebuilderform' }] },
+    });
+    if (r?.status === false)
+        return { applied: [], skipped: [...missing, ...found], error: r?.msg };
+    return { applied: found, skipped: missing };
+}
+// d) 读回某人才当前标签（data[].content = 标签名）
+async function queryEntityTags(host, talentId) {
+    const out = [];
+    for (const type of [0, 1]) {
+        try {
+            const r = await host.request({ path: '/api/my/tag/common/queryEntityTag', method: 'POST', body: { entityId: String(talentId), module: 'ebuilderform', type } });
+            const list = r?.data;
+            if (Array.isArray(list))
+                for (const t of list)
+                    out.push(t.content || t.name || t.labelName || String(t.id || ''));
+        }
+        catch { /* 读标签失败不影响主流程 */ }
+    }
+    return [...new Set(out.filter(Boolean))];
+}
+// ── 学校归属标签推导（985/211/双一流）：内置全国名单（school-tiers.json 随包分发）──
+// 由解析出的毕业院校直接推导候选，再走「环境标签清单按名求交」落库（清单里没有的自动 skip）。
+function deriveSchoolTags(structured) {
+    // 名单随 bundle 内联（resolveJsonModule）：不能用 fs 读相对路径——bundle 后 import.meta.url
+    // 指向 dist/chunks，找不到 school-tiers.json（2026-11-04 实测：学校标签推导曾因此静默失效）。
+    const cfg = schoolTiers;
+    const norm = (x) => String(x || '')
+        .replace(/[\s　]/g, '')
+        .replace(/[（(][^）)]*[)）]/g, '')
+        .replace(/^(.*?(?:大学|学院|学校)).*(?:分校|校区)$/, '$1');
+    const canon = (x) => String(cfg.aliases?.[norm(x)] || norm(x));
+    const tiers = {
+        '985': new Set(cfg['985'].map(canon)),
+        '211': new Set(cfg['211'].map(canon)),
+        '双一流': new Set(cfg['双一流'].map(canon)),
+    };
+    const schools = [...new Set(((structured || {}).academicInformations || [])
+            .map((r) => String(r.school || '').trim()).filter(Boolean))];
+    const candidates = [];
+    const detail = [];
+    const tierNames = ['985', '211', '双一流'];
+    for (const sch of schools) {
+        const c = canon(sch);
+        const hit = tierNames.filter((t) => tiers[t].has(c));
+        detail.push({ school: sch, tiers: hit });
+        for (const t of hit)
+            if (!candidates.includes(t))
+                candidates.push(t);
+        if (sch && !candidates.includes(sch))
+            candidates.push(sch); // 校名本身可能也是环境标签（不存在则自动 skip）
+    }
+    return { candidates, detail, schools };
+}
+// 文本直建：字典名称 → optionId 归一（唯一命中才写；歧义/缺失跳过并记 warning，宁缺勿错）
+function normalizeTextStructured(cache, s, warnings) {
+    const raw = cache.dict?.raw || [];
+    const byName = cache.dict?.by_name || {};
+    const dictIdByName = (name) => {
+        const k = String(name || '').trim();
+        if (!k)
+            return '';
+        let ids = byName[k];
+        if (!ids || !ids.length)
+            ids = raw.filter((x) => x.selection_name === k).map((x) => x.option_id);
+        const uniq = [...new Set((ids || []).map(String))];
+        if (!uniq.length) {
+            warnings.push('字典未找到「' + k + '」→ 该字段跳过');
+            return '';
+        }
+        if (uniq.length > 1) {
+            warnings.push('字典「' + k + '」命中 ' + uniq.length + ' 个同名选项（歧义）→ 该字段跳过');
+            return '';
+        }
+        return uniq[0];
+    };
+    const fixRows = (rows, keys) => {
+        for (const r of rows || []) {
+            if (!r || typeof r !== 'object')
+                continue;
+            for (const k of keys) {
+                const v = String(r[k] || '').trim();
+                if (!v || /^\d{6,}$/.test(v))
+                    continue;
+                const id = dictIdByName(v);
+                if (id)
+                    r[k] = id;
+                else
+                    delete r[k];
+            }
+        }
+    };
+    if (!s.gender && s.genderName) {
+        const id = dictIdByName(s.genderName);
+        if (id)
+            s.gender = id;
+    }
+    if (!s.highest_degree && s.highest_degree_name) {
+        const id = dictIdByName(s.highest_degree_name);
+        if (id)
+            s.highest_degree = id;
+    }
+    fixRows(s.academicInformations, ['edu_education', 'degree']);
+    fixRows(s.jobInformations || s.workExperiences, ['work_type']);
+    fixRows(s.internshipExperiences, ['sx_work_type']);
+    fixRows(s.languageAbilities, ['mastery', 'ls_ability', 'literacy']);
+    return s;
+}
+// ── 日期格式预检与归一（prepare 阶段前置，避免格式引发连锁失败）──
+// 实测（2026-11-05）：人才表单接口只接受 yyyy-MM-dd。模型常给「2020.11」「2008-08」「2004.09-2008.07」，
+// 会让 dataset 新增整批校验失败 → 回退 form/core 建主表 → 回退补明细又被同一格式拦下 → 明细全丢却报 success，
+// 且实测多花 3.4s（5523ms vs 2105ms）。此处统一归一：
+//   · 只有年月 → 开始补 -01、结束补当月最后一天（语义约定，写入 warnings 明示）
+//   · 「至今/现在」→ 空（表示至今，不伪造结束日）
+//   · 区间统一成 "start,end"（comma 分隔，供 DateRange 拆两键）
+//   · 无法识别 → 跳过该字段并告警（宁缺勿整批失败），绝不静默改写
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+const ONGOING_RE = /至今|现在|今|now|present/i;
+const RE_RANGE_FULL = /^\s*(\d{4}[.\-/年]\d{1,2}[.\-/月]\d{1,2}\s*日?)\s*[-–—~至,，]\s*(\d{4}[.\-/年]\d{1,2}[.\-/月]\d{1,2}\s*日?|至今|现在|今)\s*$/;
+const RE_RANGE_YM = /^\s*(\d{4}[.\-/年]\d{1,2})\s*[-–—~至,，]\s*(\d{4}[.\-/年]\d{1,2}|至今|现在|今)\s*$/;
+/** 单日期片段 → yyyy-MM-dd；isEnd=true 且缺日时补该月最后一天。无法解析返回 ''。 */
+function normDatePart(raw, isEnd) {
+    const s = String(raw ?? '').trim();
+    if (!s)
+        return '';
+    if (ONGOING_RE.test(s))
+        return '';
+    if (DATE_ONLY_RE.test(s))
+        return s;
+    const m = s.match(/^(\d{4})\s*[.\-/年]?\s*(\d{1,2})?\s*[.\-/月]?\s*(\d{1,2})?\s*日?$/);
+    if (!m)
+        return '';
+    const y = Number(m[1]);
+    const mo = m[2] ? Number(m[2]) : 1;
+    if (!y || mo < 1 || mo > 12)
+        return '';
+    const lastDay = new Date(y, mo, 0).getDate();
+    let d;
+    if (m[3]) {
+        d = Number(m[3]);
+        if (d < 1 || d > lastDay)
+            return '';
+    }
+    else {
+        d = isEnd ? lastDay : 1;
+    }
+    return y + '-' + String(mo).padStart(2, '0') + '-' + String(d).padStart(2, '0');
+}
+/** 日期区间 → "start,end"；只有单值时返回单值。 */
+function normDateRange(raw) {
+    const s = Array.isArray(raw)
+        ? raw.map((x) => String(x ?? '').trim()).filter(Boolean).join(',')
+        : String(raw ?? '').trim();
+    if (!s)
+        return '';
+    const m = s.match(RE_RANGE_FULL) || s.match(RE_RANGE_YM);
+    if (m) {
+        const a = normDatePart(m[1], false);
+        if (!a)
+            return '';
+        const b = normDatePart(m[2], true);
+        return b ? a + ',' + b : a;
+    }
+    return normDatePart(s, false);
+}
+/** 就地归一结构化简历里的全部日期字段，把每处改动写进 warnings（不静默改写）。 */
+function normalizeDates(s, warnings) {
+    if (!s || typeof s !== 'object')
+        return;
+    const one = (label, val, isEnd = false) => {
+        const before = String(val ?? '').trim();
+        if (!before)
+            return '';
+        if (ONGOING_RE.test(before))
+            return '';
+        const after = normDatePart(before, isEnd);
+        if (!after) {
+            warnings.push('日期无法识别，已跳过该字段（避免接口整批校验失败）：' + label + ' = 「' + before + '」');
+            return '';
+        }
+        if (after !== before)
+            warnings.push('日期已规范化：' + label + ' 「' + before + '」→「' + after + '」');
+        return after;
+    };
+    // 主表单值日期
+    for (const k of ['joinworkdate', 'graduate_date', 'birthday']) {
+        if (s[k] === undefined || s[k] === null)
+            continue;
+        s[k] = one(k, s[k], false);
+    }
+    // 教育经历：区间（一个组件 = 起止两个物理字段，必须 comma 分隔）
+    if (Array.isArray(s.academicInformations)) {
+        for (let i = 0; i < s.academicInformations.length; i++) {
+            const r = s.academicInformations[i];
+            if (!r || typeof r !== 'object' || r.study_date === undefined)
+                continue;
+            const before = String(r.study_date ?? '').trim();
+            if (!before)
+                continue;
+            const after = normDateRange(before);
+            if (!after) {
+                warnings.push('日期区间无法识别，已跳过（避免接口整批校验失败）：academicInformations[' + i + '].study_date = 「' + before + '」');
+                r.study_date = '';
+            }
+            else {
+                if (after !== before)
+                    warnings.push('日期已规范化：academicInformations[' + i + '].study_date 「' + before + '」→「' + after + '」');
+                r.study_date = after;
+            }
+        }
+    }
+    // 工作/项目经历：起止为两个独立字段，需分别归一后由 buildSubDetails 拼成区间
+    for (const key of ['jobInformations', 'workExperiences', 'projectExperiences']) {
+        const arr = s[key];
+        if (!Array.isArray(arr))
+            continue;
+        for (let i = 0; i < arr.length; i++) {
+            const r = arr[i];
+            if (!r || typeof r !== 'object')
+                continue;
+            if (r.start_date !== undefined && r.start_date !== null) {
+                r.start_date = one(key + '[' + i + '].start_date', r.start_date, false);
+            }
+            if (r.end_date !== undefined && r.end_date !== null) {
+                r.end_date = one(key + '[' + i + '].end_date', r.end_date, true);
+            }
+        }
+    }
+    // 实习入职时间 / 获奖日期：单值日期
+    for (const [key, field] of [['internshipExperiences', 'entry_time'], ['awardExperiences', 'award_date']]) {
+        const arr = s[key];
+        if (!Array.isArray(arr))
+            continue;
+        for (let i = 0; i < arr.length; i++) {
+            const r = arr[i];
+            if (!r || typeof r !== 'object')
+                continue;
+            if (r[field] !== undefined && r[field] !== null)
+                r[field] = one(key + '[' + i + '].' + field, r[field], false);
+        }
+    }
+}
+// 读回校验：统计各子表实际落库行数（不能只看写入接口返回，必须回读）
+async function verifySubRows(ctx, formId, objId, dataId) {
+    const L = await getFormLayoutMeta(ctx.host, formId);
+    const r = await ctx.host.request({
+        path: '/api/ebuilder/form/form/core/getFormDataAndLayout', method: 'POST',
+        body: {
+            terminalType: 'PC', dataId, formId, module: 'ebuilderform', newLayout: true,
+            layoutId: L?.formLayout?.id, layoutMultiId: L?.formLayoutMultiple?.id, dataCrossLayout: false,
+            permissionId: '', allReadOnly: true, initialDatas: [], dynamicData: false, cost: false,
+            customParam: { objId, dataId },
+        },
+    });
+    const dets = r?.data?.formData?.dataDetails || [];
+    const seen = {};
+    for (const d of dets) {
+        if (!d.subFormId)
+            continue;
+        const k = String(d.subFormId);
+        (seen[k] = seen[k] || new Set()).add(String(d.dataIndex));
+    }
+    const rowsBySubFormId = {};
+    for (const [k, s] of Object.entries(seen))
+        rowsBySubFormId[k] = s.size;
+    return {
+        cells: dets.filter((d) => d.subFormId).length,
+        rowsBySubFormId,
+        rowTotal: Object.values(rowsBySubFormId).reduce((a, b) => a + b, 0),
+    };
+}
+async function loadStructured(ctx, args) {
+    const warnings = [];
+    if (args.structured !== undefined) {
+        const s = typeof args.structured === 'string' ? JSON.parse(args.structured) : args.structured;
+        if (!s || typeof s !== 'object')
+            throw rsValidationError('structured_invalid', 'structured 必须是 JSON 对象');
+        if (!String(s.telephone || '').trim() && !String(s.candidateName || '').trim()) {
+            throw rsValidationError('structured_invalid', '结构化简历缺少 telephone 与 candidateName（至少要有手机号或姓名，否则无法查重建档）');
+        }
+        const normalizedInline = normalizeTextStructured(ctx.cache, s, warnings);
+        normalizeDates(normalizedInline, warnings);
+        return { structured: normalizedInline, textMode: true, warnings };
+    }
+    if (args.structuredFile) {
+        const p = path.resolve(String(args.structuredFile));
+        const s = JSON.parse(fs.readFileSync(p, 'utf8'));
+        if (!s || typeof s !== 'object')
+            throw rsValidationError('structured_invalid', 'structuredFile 内容不是合法 JSON 对象');
+        if (!String(s.telephone || '').trim() && !String(s.candidateName || '').trim()) {
+            throw rsValidationError('structured_invalid', '结构化简历缺少 telephone 与 candidateName');
+        }
+        const normalizedFile = normalizeTextStructured(ctx.cache, s, warnings);
+        normalizeDates(normalizedFile, warnings);
+        return { structured: normalizedFile, textMode: true, warnings };
+    }
+    return { structured: null, textMode: false, warnings };
+}
+async function buildImport(ctx, args) {
+    const { host, baseUrl, appId, cache } = ctx;
+    const objId = objIdOf(cache, 'talent_pool');
+    const formId = formIdOf(cache, 'talent_pool');
+    const fields = cache.fields[objId] || {};
+    if (!fields.candidate_name || !fields.telephone)
+        throw rsFail('环境缓存缺人才表单字段 candidate_name/telephone');
+    const resumeFieldId = fields.original_resume || '937153853968539861';
+    const { structured: loaded, textMode, warnings: structuredTextWarnings } = await loadStructured(ctx, args);
+    let structured = loaded;
+    // 上传：有本地文件时把原件传进附件字段
+    let fileid = args.fileId ? String(args.fileId) : '';
+    let fileName = null;
+    if (!fileid && args.resumeFile) {
+        const up = await uploadResume(host, baseUrl, path.resolve(String(args.resumeFile)), resumeFieldId, formId);
+        fileid = up.fileid;
+        fileName = up.name;
+    }
+    if (!textMode) {
+        if (!fileid)
+            throw rsFail('需要 resumeFile 或 fileId（附件必须上传）；解析请由大模型按 schema 整理后走 structured 输入');
+        if (!args.useOcr) {
+            throw rsFail('解析默认由大模型完成（structured 输入），不自动调 OCR。确需 OCR 兜底（如扫描件）请显式 useOcr:true 重试（闸门=checkResumeExtraction）。');
+        }
+        structured = await extractResume(host, fileid);
+    }
+    // 学校归属标签推导（并入标签候选）
+    const schoolTagInfo = args.noSchoolTags ? { candidates: [], detail: [], schools: [] } : deriveSchoolTags(structured);
+    const tagNames = [...(args.tags || [])];
+    for (const t of schoolTagInfo.candidates)
+        if (!tagNames.includes(t))
+            tagNames.push(t);
+    // 字段映射 + 附件
+    const dataDetails = mapToTalent(fields, structured);
+    if (fileid) {
+        dataDetails.push({ formField: { id: resumeFieldId }, dataOptions: [{ optionId: String(fileid), content: fileName || '简历附件', type: 'file' }] });
+    }
+    // 渠道：显式 channel 优先；未指定时固定「手动录入」
+    let channelLabel = null;
+    if (args.channel) {
+        let channelOption;
+        for (const x of cache.dict?.raw || [])
+            if (x.selection_name === args.channel)
+                channelOption = x.option_id;
+        if (!channelOption)
+            throw rsFail('渠道「' + args.channel + '」未在字典中找到（不得臆造 optionId）');
+        dataDetails.push({ formField: { id: fields.channel }, dataOptions: [{ optionId: channelOption, content: args.channel }] });
+        channelLabel = args.channel;
+    }
+    else if (fields.channel) {
+        const byName = cache.dict?.by_name || {};
+        const manualId = (byName['手动录入'] || byName['手工录入'] || [])[0];
+        if (!manualId)
+            throw rsFail('数据字典中未找到「手动录入」，无法固定简历来源（不得臆造 optionId）');
+        dataDetails.push({ formField: { id: fields.channel }, dataOptions: [{ optionId: String(manualId), content: '手动录入' }] });
+        channelLabel = '手动录入（固定）';
+    }
+    // 是否黑名单：固定「否」（选项 id 运行时按名称反查）
+    if (fields.is_blacklist) {
+        const opt = (cache.field_options?.[objId] || {})[fields.is_blacklist] || {};
+        const noId = Object.keys(opt).find((k) => opt[k] === '否');
+        if (noId)
+            dataDetails.push({ formField: { id: fields.is_blacklist }, dataOptions: [{ optionId: String(noId), content: '否' }] });
+    }
+    // 明细表：数据集通道；节点名 detail1..N 由 getTableMapping 运行时解析（顺序≠布局顺序）
+    let subBuild = { byTable: {}, stats: {} };
+    let subMeta = {};
+    let subError = null;
+    const detailsPayload = {};
+    const detailNodes = {};
+    const unmappedTables = [];
+    try {
+        subMeta = await resolveSubTableMeta(ctx);
+        subBuild = buildSubDetails(structured, subMeta, cache);
+        const mapping = await getTableMapping(host, objId);
+        const nodeOf = invertTableMapping(mapping);
+        for (const [dk, rows] of Object.entries(subBuild.byTable)) {
+            const sub = subMeta[dk];
+            const node = sub ? nodeOf[String(sub.subFormId)] : null;
+            if (!node) {
+                unmappedTables.push(dk);
+                continue;
+            }
+            detailsPayload[node] = rows;
+            detailNodes[dk] = node;
+        }
+    }
+    catch (e) {
+        subError = e.message;
+    }
+    const subRowTotal = Object.values(subBuild.byTable).reduce((n, rows) => n + rows.length, 0);
+    return {
+        objId, formId, fields, fileid, fileName, structured, textMode, structuredTextWarnings,
+        dataDetails, detailsPayload, detailNodes, unmappedTables, subError, subBuild, subRowTotal,
+        subMeta, tagNames, schoolTagInfo, channelLabel, resumeFieldId,
+    };
+}
+// 两级查重：① getCandidateByPhone（页面同款，命中即「已绑定人才」）② checkUnique（表单唯一性，捕捉无批次记录与软删除占用）
+async function findExistingTalents(ctx, opts) {
+    const { objId, formId, fields, mobile } = opts;
+    const blank = { checked: false, unique: true, byPhone: null, byPhoneError: undefined, formConflicts: { existing: [], unreadable: [] }, ids: [] };
+    if (!mobile)
+        return blank;
+    // 两级查重并行：getCandidateByPhone（页面同款）与 checkUnique（表单唯一性）互不依赖 → 并行省 1 RTT。
+    // 只并行「查询层」：后续 readBrief 过滤依赖 byPhone 结果，保持串行。两者均为只读 POST，无副作用；
+    // 包装成永不 reject 的 task（失败仅记录），错误语义与串行版一致（byPhone 记录 error、checkUnique 忽略）。
+    const phoneTask = getCandidateByPhone(ctx.host, mobile).then((b) => ({ ok: true, b }), (e) => ({ ok: false, e }));
+    const uniqueTask = fields.telephone
+        ? checkUnique(ctx.host, { objId, fieldId: fields.telephone, value: mobile }).then((r) => ({ ok: true, r }), () => ({ ok: false, r: null }))
+        : Promise.resolve({ ok: false, r: null });
+    const [phoneRes, uniqueRes] = await Promise.all([phoneTask, uniqueTask]);
+    let byPhone = null;
+    if (phoneRes.ok) {
+        const b = phoneRes.b;
+        if (b.candidateId || b.talentId) {
+            byPhone = {
+                talentId: b.talentId,
+                candidateId: b.candidateId,
+                talentViewUrl: b.candidateId ? buildTalentViewUrl(ctx.baseUrl, b.candidateId) : null,
+                talentCardUrl: b.talentId ? resolveTalentCardUrl(ctx, b.talentId) : null,
+                talentListLocateUrl: b.talentId ? resolveTalentListLocateUrl(ctx, b.talentId) : null,
+            };
+        }
+    }
+    else {
+        byPhone = { error: phoneRes.e?.message };
+    }
+    const formConflicts = { existing: [], unreadable: [] };
+    let ids = [];
+    if (uniqueRes.ok && uniqueRes.r) {
+        const r = uniqueRes.r;
+        ids = r.formDataIds;
+        const readBrief = makeBriefReader(ctx, formId, objId, fields);
+        for (const id of ids) {
+            if (byPhone?.talentId === id)
+                continue;
+            const rec = await readBrief(id);
+            if (rec) {
+                formConflicts.existing.push({
+                    talentId: id, ...rec,
+                    talentCardUrl: resolveTalentCardUrl(ctx, id),
+                    talentListLocateUrl: resolveTalentListLocateUrl(ctx, id),
+                    recordCardUrl: buildCardUrl(ctx.baseUrl, objId, id),
+                });
+            }
+            else
+                formConflicts.unreadable.push(id);
+        }
+    }
+    const hit = Boolean(byPhone?.candidateId || byPhone?.talentId) || formConflicts.existing.length > 0;
+    return { checked: true, unique: !hit, byPhone: byPhone && !byPhone.error ? byPhone : null, byPhoneError: byPhone?.error, formConflicts, ids };
+}
+function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+/**
+ * 指纹用主表：剔除附件字段（original_resume）。
+ * 附件每次上传都会生成新的 fileid，属 volatile 字段；若参与指纹，prepare 与 apply 必然不一致
+ * （2026-11-04 实测：同一 PDF 两次上传 fileid 不同 → update 模式必报 fingerprint_mismatch）。
+ * 附件内容由 fileid 指向，用户确认时看的是文件名/份数，剔除不影响确认语义。
+ */
+function fingerprintMainTable(mainTable) {
+    const copy = { ...mainTable };
+    delete copy.original_resume;
+    return copy;
+}
+const baseInput = {
+    structured: { type: 'object', description: '大模型按 schema 整理的结构化简历对象（解析主通道；与 structuredFile 二选一）' },
+    structuredFile: { type: 'string', description: '结构化简历 JSON 文件路径（兼容脚本版用法）' },
+    fileId: { type: 'string', description: '已上传到 E10 的简历附件 id（原件写进附件字段）' },
+    resumeFile: { type: 'string', description: '本地简历文件路径（两步 multipart 上传）' },
+    channel: { type: 'string', description: '简历渠道（须在数据字典中存在；缺省固定「手动录入」）' },
+    tags: { type: 'array', items: { type: 'string' }, maxItems: 20, description: '平台标签名（按名命中环境清单，不存在跳过；学校归属自动推导另算）' },
+    useOcr: { type: 'boolean', description: '显式开启 OCR 兜底解析（闸门=checkResumeExtraction；默认永不上调）' },
+    noSchoolTags: { type: 'boolean', description: '关闭学校归属标签自动推导' },
+    updateTalentId: { type: 'string', description: '按简历更新已有人才（主表全量覆盖+明细整表覆盖；先 prepare 看差异）' },
+};
+async function prepare(args, env) {
+    const host = env.host;
+    const session = await host.getSession();
+    const ctx = { host, baseUrl: session.baseUrl.replace(/\/+$/, ''), appId: '', cache: await env.recruitContext() };
+    ctx.appId = ctx.cache.appId;
+    const argsT = args;
+    if (!argsT.structured && !argsT.structuredFile && !argsT.fileId && !argsT.resumeFile) {
+        throw rsValidationError('input_required', '需要 structured/structuredFile/fileId/resumeFile 之一');
+    }
+    const built = await buildImport(ctx, argsT);
+    // 更新模式：出差异摘要
+    if (argsT.updateTalentId) {
+        const updateTalentId = String(argsT.updateTalentId);
+        const snapshot = await readTalentSnapshot(ctx, { formId: built.formId, objId: built.objId, fields: built.fields, subMeta: built.subMeta, dataId: updateTalentId });
+        const upMain = toDatasetMainTable(built.dataDetails, built.fields);
+        const protectedSkipped = [];
+        for (const k of PROTECTED_UPDATE_KEYS) {
+            if (k in upMain) {
+                delete upMain[k];
+                protectedSkipped.push(k);
+            }
+        }
+        // 口径统一：快照是展示值，待写是 optionId —— 待写值反查成展示值再比，避免把"没变"误报成"覆盖"
+        const dictName = makeDictLookup(ctx.cache);
+        const fo = (ctx.cache.field_options || {})[built.objId] || {};
+        const displayOf = (key, v) => {
+            const s = String(v ?? '');
+            if (key === 'original_resume')
+                return s ? '（附件）' : '';
+            if (!/^\d{6,}$/.test(s))
+                return s;
+            const dn = dictName(s);
+            if (dn)
+                return dn;
+            const map = built.fields[key] ? fo[built.fields[key]] : null;
+            if (map && map[s])
+                return map[s];
+            return s;
+        };
+        const fieldDiff = Object.entries(upMain).map(([k, v]) => {
+            const old = snapshot.main[k] ?? '';
+            const newDisplay = displayOf(k, v);
+            const same = String(old) === newDisplay;
+            return {
+                field: k, old, new: newDisplay, rawValue: String(v),
+                change: same ? 'same' : (k === 'original_resume' ? 'replace-attachment' : (old === '' ? 'fill' : 'overwrite')),
+            };
+        });
+        const changed = fieldDiff.filter((x) => x.change !== 'same');
+        const detailDiff = Object.entries(built.detailsPayload).map(([node, rows]) => {
+            const dk = Object.keys(built.detailNodes).find((k) => built.detailNodes[k] === node) || node;
+            return { table: dk, node, oldRows: snapshot.subRows[dk] || 0, newRows: rows.length, action: 'cover' };
+        });
+        const coveredKeys = new Set(Object.keys(built.detailNodes));
+        const keptTables = Object.keys(built.subMeta).filter((k) => !coveredKeys.has(k) || !(built.detailNodes[k] in built.detailsPayload));
+        let viewUrl = null;
+        try {
+            const b = await getCandidateByPhone(ctx.host, built.structured.telephone || '');
+            if (b.candidateId)
+                viewUrl = buildTalentViewUrl(ctx.baseUrl, b.candidateId);
+        }
+        catch { /* 查不到批次不影响更新 */ }
+        const willSubmit = { updateTalentId, mainTable: fingerprintMainTable(upMain), details: built.detailsPayload };
+        const fp = fingerprint(willSubmit);
+        const continuation = await env.continuation.issue({ operation: 'recruit-stage.resume.import.apply', fingerprint: fp });
+        return rsSuccess('recruit-stage.resume.import.prepare', {
+            mode: 'prepare-update',
+            action: '按简历更新已有人才',
+            talentId: updateTalentId,
+            strategy: { main: 'B 全量覆盖（简历解析出的字段全部写入）', details: '整表覆盖（仅覆盖简历解析出数据的表）' },
+            changes: changed,
+            unchanged: fieldDiff.filter((x) => x.change === 'same').map((x) => x.field),
+            details: detailDiff,
+            detailPreview: Object.fromEntries(Object.entries(built.detailsPayload).map(([n, rows]) => [n, rows[0]])),
+            keptTables,
+            protectedSkipped,
+            talentViewUrl: viewUrl,
+            note: '以上为将写入的差异。确认后 apply 执行；全量覆盖会改掉人工修正过的值',
+        }, { continuation, fingerprint: fp, confirmHint: '用户明确确认后，携带 confirm:true 与 continuation 调用 apply' });
+    }
+    // 查重与标签预检互不依赖 → 并行（标签清单分页通常多 RTT，与查重力求重叠）。
+    // tagCheckTask 内部自带 try/catch，永不 reject，避免查重先抛错时产生 unhandledRejection。
+    const tagCheckTask = (async () => {
+        if (!built.tagNames.length)
+            return null;
+        try {
+            const rt = await resolveTags(ctx.host, built.tagNames);
+            return { requested: built.tagNames, found: rt.found, missing: rt.missing, ...(typeof rt.availableCount === 'number' ? { availableCount: rt.availableCount } : {}) };
+        }
+        catch (e) {
+            return { requested: built.tagNames, error: e.message };
+        }
+    })();
+    const [dupInfo, tagCheck] = await Promise.all([
+        findExistingTalents(ctx, { objId: built.objId, formId: built.formId, fields: built.fields, mobile: built.structured.telephone }),
+        tagCheckTask,
+    ]);
+    const summary = {
+        action: '简历导入建人才',
+        resumeFile: built.fileName || ('fileid=' + built.fileid),
+        // 供 apply 复用：传 fileId 即可跳过二次上传（附件已在本环境，省一次 multipart）
+        resumeFileId: built.fileid || undefined,
+        parsed: {
+            name: built.structured.candidateName, mobile: built.structured.telephone, email: built.structured.email || '(空)',
+            gender: built.structured.genderName, birthday: built.structured.birthday, age: built.structured.age,
+            degree: built.structured.highest_degree_name, college: built.structured.college,
+            joinworkdate: built.structured.joinworkdate, intendPosition: built.structured.intend_position,
+            jobCount: (built.structured.jobInformations || []).length, projectCount: (built.structured.projectExperiences || []).length,
+        },
+        mappedFieldCount: built.dataDetails.length,
+        channel: built.channelLabel || '(未指定)',
+        subTables: built.subBuild.stats,
+        subTableRows: built.subRowTotal,
+        subTableNodes: built.detailNodes,
+        subTableUnmapped: built.unmappedTables.length ? built.unmappedTables : undefined,
+        subTableError: built.subError || undefined,
+        structuredWarnings: built.structuredTextWarnings.length ? built.structuredTextWarnings : undefined,
+        duplicate: {
+            checked: dupInfo.checked,
+            unique: dupInfo.unique,
+            bound: dupInfo.byPhone,
+            formConflicts: dupInfo.formConflicts.existing,
+            unreadableIds: dupInfo.formConflicts.unreadable,
+            byPhoneError: dupInfo.byPhoneError,
+            note: dupInfo.byPhone
+                ? '手机号已绑定人才（页面同款 getCandidateByPhone 命中）→ 不新建，给出人才查看页地址'
+                : (dupInfo.formConflicts.existing.length
+                    ? '手机号在人才库已存在（表单唯一性命中，但无应聘批次）→ 不新建'
+                    : (dupInfo.formConflicts.unreadable.length
+                        ? '手机号被已删除记录占用（平台仍会拦新建）：需先在回收站清理，或改为更新已有人才'
+                        : '无重复')),
+        },
+    };
+    const willSubmit = { formId: built.formId, objId: built.objId, mainTable: fingerprintMainTable(toDatasetMainTable(built.dataDetails, built.fields)), details: built.detailsPayload };
+    const fp = fingerprint(willSubmit);
+    const continuation = await env.continuation.issue({ operation: 'recruit-stage.resume.import.apply', fingerprint: fp });
+    return rsSuccess('recruit-stage.resume.import.prepare', {
+        mode: 'prepare', ...summary,
+        willSubmit,
+        tagCheck,
+        schoolTags: built.schoolTagInfo,
+        onCommit: '提交后将：① dataset/v2/saveFormData 建人才（主表+明细一次写入）② 初始化人才批次 ③ 触发人才自动标签规则匹配 ④ 按标签（含学校归属自动推导）写入平台标签 ⑤ 输出人才卡片/人才库定位链接',
+    }, { continuation, fingerprint: fp, confirmHint: '用户明确确认后，携带 confirm:true 与 continuation 调用 apply' });
+}
+async function apply(args, env) {
+    if (args.confirm !== true)
+        throw rsConfirmationError('recruit-stage.resume.import.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.resume.import.apply');
+    const host = env.host;
+    const session = await host.getSession();
+    const ctx = { host, baseUrl: session.baseUrl.replace(/\/+$/, ''), appId: '', cache: await env.recruitContext() };
+    ctx.appId = ctx.cache.appId;
+    const argsT = args;
+    const built = await buildImport(ctx, argsT);
+    // 更新模式
+    if (argsT.updateTalentId) {
+        const updateTalentId = String(argsT.updateTalentId);
+        const upMain = toDatasetMainTable(built.dataDetails, built.fields);
+        for (const k of PROTECTED_UPDATE_KEYS)
+            delete upMain[k];
+        const willSubmit = { updateTalentId, mainTable: fingerprintMainTable(upMain), details: built.detailsPayload };
+        if (payload.fingerprint !== fingerprint(willSubmit)) {
+            throw rsValidationError('fingerprint_mismatch', '待提交内容与 prepare 确认摘要不一致，请重新 prepare 确认后再 apply');
+        }
+        await datasetUpdateFormData(host, {
+            objId: built.objId, dataId: updateTalentId, mainTable: upMain,
+            details: built.detailsPayload, coverDetails: Object.keys(built.detailsPayload),
+        });
+        // 自检：行数与格数都要对得上；落库有短暂延迟，首读不符等 600ms 重读一次再判定
+        const checkAfter = (snap) => {
+            const out = [];
+            for (const [node, rows] of Object.entries(built.detailsPayload)) {
+                const dk = Object.keys(built.detailNodes).find((k) => built.detailNodes[k] === node) || node;
+                const wantCells = rows.reduce((n, r) => n + Object.keys(r).length, 0);
+                const gotRows = snap.subRows[dk] || 0;
+                const gotCells = snap.subCells[dk] || 0;
+                if (gotRows !== rows.length || gotCells !== wantCells) {
+                    out.push(`${dk}：期望 ${rows.length} 行/${wantCells} 格，读回 ${gotRows} 行/${gotCells} 格`);
+                }
+            }
+            return out;
+        };
+        let after = await readTalentSnapshot(ctx, { formId: built.formId, objId: built.objId, fields: built.fields, subMeta: built.subMeta, dataId: updateTalentId });
+        let verifyWarnings = checkAfter(after);
+        if (verifyWarnings.length) {
+            await new Promise((r) => setTimeout(r, 600));
+            after = await readTalentSnapshot(ctx, { formId: built.formId, objId: built.objId, fields: built.fields, subMeta: built.subMeta, dataId: updateTalentId });
+            verifyWarnings = checkAfter(after);
+        }
+        return rsSuccess('recruit-stage.resume.import.apply', {
+            // 更新模式同理：明细行/格数对不上时只能报 partial，不能因主表写入成功就报 success
+            mode: 'update', result: verifyWarnings.length ? 'partial' : 'success',
+            detailsState: verifyWarnings.length ? 'missing' : 'complete',
+            talentId: updateTalentId,
+            afterSummary: { mainFieldCount: Object.keys(after.main).length, subRows: after.subRows, subCells: after.subCells },
+            verifyWarnings: verifyWarnings.length ? verifyWarnings : undefined,
+            talentCardUrl: resolveTalentCardUrl(ctx, updateTalentId),
+            talentListLocateUrl: resolveTalentListLocateUrl(ctx, updateTalentId),
+            parsed: { name: built.structured.candidateName, mobile: built.structured.telephone, email: built.structured.email || '(空)' },
+        });
+    }
+    // 新建模式：查重阻断
+    const dupInfo = await findExistingTalents(ctx, { objId: built.objId, formId: built.formId, fields: built.fields, mobile: built.structured.telephone });
+    if (dupInfo.byPhone?.candidateId || dupInfo.byPhone?.talentId) {
+        const b = dupInfo.byPhone;
+        return rsSuccess('recruit-stage.resume.import.apply', {
+            mode: 'apply', result: 'duplicate',
+            message: '当前手机号已绑定人才信息，按页面规则不新建（未写入任何数据）',
+            existingTalent: { talentId: b.talentId, candidateId: b.candidateId, talentViewUrl: b.talentViewUrl, talentCardUrl: b.talentCardUrl },
+            talentViewUrl: b.talentViewUrl,
+            otherRecords: dupInfo.formConflicts.existing.length ? dupInfo.formConflicts.existing : undefined,
+            parsed: { name: built.structured.candidateName, mobile: built.structured.telephone },
+            nextStep: '如需按这份简历更新该人才，明确说明即可（updateTalentId 走更新通道）',
+        });
+    }
+    if (dupInfo.formConflicts.existing.length) {
+        return rsSuccess('recruit-stage.resume.import.apply', {
+            mode: 'apply', result: 'duplicate',
+            message: '手机号在人才库已存在（表单唯一性命中，但无应聘批次），不新建（未写入任何数据）',
+            formConflicts: dupInfo.formConflicts.existing,
+            parsed: { name: built.structured.candidateName, mobile: built.structured.telephone },
+            nextStep: '如需按这份简历更新该人才，明确说明即可（updateTalentId 走更新通道）',
+        });
+    }
+    if (!dupInfo.unique && dupInfo.formConflicts.unreadable.length) {
+        throw rsFail('手机号被 ' + dupInfo.formConflicts.unreadable.length + ' 条已删除记录占用（平台唯一性校验仍拦新建，id=' + dupInfo.formConflicts.unreadable.join(',') + '）：请先在回收站清理，或改为更新已有人才');
+    }
+    // 建人才：① 首选数据集通道（主表+明细一次写入）；② 被拦时回退页面级主表 + 数据集 update 补明细
+    const datasetMain = toDatasetMainTable(built.dataDetails, built.fields);
+    let newId = '';
+    let writeChannel = '';
+    const writeWarnings = [];
+    try {
+        const created = await datasetSaveFormData(host, { objId: built.objId, mainTable: datasetMain, details: built.detailsPayload });
+        newId = created.dataId;
+        writeChannel = 'dataset/v2/saveFormData（主表 + 明细一次写入）';
+    }
+    catch (e) {
+        writeWarnings.push('数据集新增未通过（' + e.message + '），改为建主表后用数据集 update 补明细');
+        newId = await saveFormData(host, { appId: ctx.appId, formId: built.formId, objId: built.objId, name: built.structured.candidateName || '简历导入', dataDetails: built.dataDetails });
+        writeChannel = 'form/core/saveFormData（主表）+ dataset/v2/updateFormData（明细）';
+        if (Object.keys(built.detailsPayload).length) {
+            try {
+                // 新建记录的明细必然为空 → 走「追加」即可。不用 cover：实测 cover 会重建整行，把 EBuilder（关联）列清空。
+                await datasetUpdateFormData(host, { objId: built.objId, dataId: newId, mainTable: {}, details: built.detailsPayload });
+            }
+            catch (e2) {
+                writeWarnings.push('回退后补明细失败：' + e2.message);
+            }
+        }
+    }
+    const r2 = await host.request({ path: '/api/recruit/candidate/initTalentBatch?formDataId=' + newId, method: 'POST' });
+    const talentId = String(newId);
+    // 写后 4 件事并行（都只依赖 talentId、彼此无依赖）：
+    //   ① verifySubRows 回读明细校验（读）
+    //   ② runSaveButtonEsbActions 执行「保存」按钮 esb 动作流（写副作用：建日程/通知等）
+    //   ③ matchTalentLabel 触发后台智能标签规则（写：规则匹配，与平台标签属不同体系）
+    //   ④ addEntityTags 写平台标签（内部「按名解析 → 写入」两步）
+    // initTalentBatch 保持在前串行：它是批次初始化，失败应阻断后续（与原语义一致）。
+    // 每个 task 用 .then 包装错误，Promise.all 消费全部 → 各自失败互不影响（与原 try/catch 等价）。
+    const [verifyRes, esbRes, labelRes, tagRes] = await Promise.all([
+        verifySubRows(ctx, built.formId, built.objId, newId).then((v) => ({ ok: true, v }), (e) => ({ ok: false, e })),
+        runSaveButtonEsbActions(host, { objId: built.objId, formId: built.formId, dataId: newId }).then((v) => ({ ok: true, v }), (e) => ({ ok: false, e })),
+        matchTalentLabel(host, talentId).then((v) => ({ ok: true, v }), (e) => ({ ok: false, e })),
+        addEntityTags(host, talentId, built.tagNames).then((v) => ({ ok: true, v }), (e) => ({ ok: false, e })),
+    ]);
+    const subTableVerify = verifyRes.ok ? verifyRes.v : { error: verifyRes.e?.message };
+    // 明细完整性判定：主表建成 ≠ 建档成功。实测（2026-11-05）出现过主表 19 字段写入成功、
+    // 18 行明细 0 行落库，而返回仍是 result=success —— 只看 writeWarnings 才会发现问题。
+    // 规则：期望行数 > 0 时读回行数必须 >= 期望，否则 result 只能报 partial；回读失败则标 unverified。
+    let detailsState = 'complete';
+    if (!verifyRes.ok) {
+        detailsState = 'unverified';
+        writeWarnings.push('明细读回校验失败（无法确认明细是否落库）：' + (verifyRes.e?.message || ''));
+    }
+    else if (built.subRowTotal > 0) {
+        const gotRows = Number(subTableVerify?.rowTotal || 0);
+        if (gotRows < built.subRowTotal) {
+            detailsState = 'missing';
+            writeWarnings.push('明细行未完整落库（期望 ' + built.subRowTotal + ' 行，读回 ' + gotRows + ' 行）：主表已写入，请按 writeWarnings 修正后走 updateTalentId 补明细');
+        }
+    }
+    const saveEsbActions = esbRes.ok ? esbRes.v : { error: esbRes.e?.message };
+    const labelMatch = labelRes.ok ? labelRes.v : 'ERR:' + (labelRes.e?.message || '');
+    const tagResult = tagRes.ok
+        ? tagRes.v
+        : { applied: [], skipped: built.tagNames, error: tagRes.e?.message };
+    // 标签回读依赖写入结果，放在并行组之后（写操作可验证优先）
+    const tags = await queryEntityTags(host, talentId).catch(() => []);
+    const talentCardUrl = resolveTalentCardUrl(ctx, talentId);
+    const talentListLocateUrl = resolveTalentListLocateUrl(ctx, talentId);
+    return rsSuccess('recruit-stage.resume.import.apply', {
+        mode: 'apply', result: detailsState === 'complete' ? 'success' : 'partial',
+        detailsState,
+        newCandidateFormDataId: newId,
+        talentId,
+        writeChannel,
+        writeWarnings: writeWarnings.length ? writeWarnings : undefined,
+        subTablesExpected: built.subBuild.stats,
+        subTableVerify,
+        initTalentBatch: r2?.data?.msg || '',
+        saveEsbActions,
+        schoolTags: built.schoolTagInfo,
+        labelMatch,
+        tagsApplied: tagResult.applied,
+        tagsSkipped: tagResult.skipped,
+        tags,
+        talentCardUrl,
+        talentListLocateUrl,
+        // 产物链接（Agent 原样搬运：① 人才卡片 ② 人才库定位；缺失哪个只给另一个）
+        viewLink: talentCardUrl ? `[查看 ${built.structured.candidateName || '新人才'} 的人才卡片](${talentCardUrl})` : null,
+        listLocateLink: talentListLocateUrl ? `[在人才库中打开](${talentListLocateUrl})` : null,
+        agentNote: '正文给两个 Markdown 链接——① [查看 <姓名> 的人才卡片](talentCardUrl) ② [在人才库中打开](talentListLocateUrl)；缺失哪个就只给另一个，不输出半截。不要用 artifact / browsertool。',
+        parsed: {
+            name: built.structured.candidateName, mobile: built.structured.telephone, email: built.structured.email || '(空)',
+            gender: built.structured.genderName, degree: built.structured.highest_degree_name, college: built.structured.college,
+        },
+    });
+}
+export const resumeImportOperations = [
+    {
+        name: 'recruit-stage.resume.import.prepare',
+        resource: 'recruit.resume',
+        method: 'prepare',
+        action: 'resume.import.prepare',
+        summary: '简历导入确认摘要：解析结果+字段映射+两级查重（页面同款）+标签预核（含学校归属自动推导）；更新模式出字段/明细差异；不写入',
+        capability: 'recruit.resume.import',
+        risk: 'write',
+        requiresConfirmation: true,
+        inputSchema: schemaOf(baseInput, {}),
+        handler: prepare,
+    },
+    {
+        name: 'recruit-stage.resume.import.apply',
+        resource: 'recruit.resume',
+        method: 'apply',
+        action: 'resume.import.apply',
+        summary: '用户确认后建档：数据集通道主表+明细一次写入（被拦回退）、初始化批次、触发规则标签、写平台标签、读回校验；返回人才卡片/人才库双链接',
+        capability: 'recruit.resume.import',
+        risk: 'write',
+        requiresConfirmation: true,
+        inputSchema: schemaOf({ ...baseInput, confirm: { type: 'boolean' }, continuation: { type: 'string' } }, {}),
+        handler: apply,
+    },
+];
+void findMenuNode;
+void randHex32;